# Django 6.0.7 documentation

# Django Verktyg

Detta dokument täcker alla stabila moduler i `django.utils`. De flesta av modulerna i `django.utils` är utformade för internt bruk och endast följande delar kan betraktas som stabila och därmed bakåtkompatibla enligt internal release deprecation policy.

## `django.utils.cache`

Denna modul innehåller hjälpfunktioner för att kontrollera HTTP-cachning. Detta görs genom att hantera `Vary`-headern i svaren. Den innehåller funktioner för att patcha svarsobjektens header direkt och dekoratorer som ändrar funktioner så att de själva gör header-patchningen.

För information om rubriken `Vary`, se RFC 9110#avsnitt-12.5.5.

I huvudsak definierar HTTP-headern `Vary` vilka headers en cache ska ta hänsyn till när den bygger sin cache-nyckel. Förfrågningar med samma sökväg men olika rubrikinnehåll för rubriker som namnges i `Vary` måste få olika cache-nycklar för att förhindra leverans av fel innehåll.

Exempelvis skulle internationization middleware behöva skilja cacher åt genom `Accept-language`-headern.

patch_cache_control(response, **kwargs)

  Denna funktion patchar `Cache-Control`-headern genom att lägga till alla nyckelordsargument till den. Omvandlingen är som följer:

  - Alla parameternamn för nyckelord ändras till gemener och understrykningar konverteras till bindestreck.

  - Om värdet på en parameter är `True` (exakt `True`, inte bara ett sant värde), läggs endast parameternamnet till i sidhuvudet.

  - Alla andra parametrar läggs till med sitt värde, efter att ha applicerat `str()` på det.

get_max_age(response)

  Returnerar max-age från svarets Cache-Control-huvud som ett heltal (eller `None` om det inte hittades eller inte var ett heltal).

patch_response_headers(response, cache_timeout=None)

  Lägger till några användbara rubriker till det givna `HttpResponse`-objektet:

  - `Utgångsdatum`

  - `Cache-Control`

  Varje rubrik läggs bara till om den inte redan är inställd.

  `cache_timeout` anges i sekunder. Inställningen `CACHE_MIDDLEWARE_SECONDS` används som standard.

add_never_cache_headers(response)

  Lägger till en `Expires`-rubrik till aktuellt datum/tid.

  Lägger till en `Cache-Control: max-age=0, no-cache, no-store, must-revalidate, private` header till ett svar för att ange att en sida aldrig ska cachas.

  Varje rubrik läggs bara till om den inte redan är inställd.

patch_vary_headers(response, newheaders)

  Lägger till (eller uppdaterar) `Vary`-headern i det givna `HttpResponse`-objektet. `newheaders` är en lista med headernamn som bör finnas i `Vary`. Om headers innehåller en asterisk, då kommer `Vary` header att bestå av en enda asterisk `'*'`, enligt RFC 9110 Section 12.5.5. Annars tas inte befintliga rubriker i `Vary` bort.

get_cache_key(request, key_prefix=None, method='GET', cache=None)

  Returnerar en cache-nyckel baserad på sökvägen för begäran. Den kan användas i begärandefasen eftersom den hämtar listan över rubriker att ta hänsyn till från det globala sökvägsregistret och använder dem för att bygga en cachekod att kontrollera mot.

  Om det inte finns någon headerlist lagrad måste sidan byggas om, så denna funktion returnerar `None`.

learn_cache_key(request, response, cache_timeout=None, key_prefix=None, cache=None)

  Lär sig vilka rubriker som ska tas hänsyn till för en viss sökväg från svarsobjektet. Det lagrar dessa rubriker i ett globalt sökvägsregister så att senare åtkomst till sökvägen vet vilka rubriker som ska beaktas utan att bygga själva svarsobjektet. Rubrikerna namnges i `Vary`-rubriken i svaret, men vi vill förhindra att svaret genereras.

  Listan över rubriker som ska användas för att generera cache-nyckeln lagras i samma cache som själva sidorna. Om cachen åldrar vissa data ur cachen innebär det att vi måste bygga svaret en gång för att komma åt Vary-rubriken och därmed listan över rubriker som ska användas för cachekoden.

## `django.utils.dateparse`

De funktioner som definieras i denna modul har följande egenskaper:

- De accepterar strängar i ISO 8601 datum/tidsformat (eller några närliggande alternativ) och returnerar objekt från motsvarande klasser i Pythons `datetime`-modul.

- De ger upphov till `ValueError` om deras indata är väl formaterad men inte är ett giltigt datum eller en giltig tid.

- De returnerar `None` om det inte är väl formaterat alls.

- De accepterar upp till pikosekundupplösning i indata, men de trunkerar det till mikrosekunder, eftersom det är vad Python stöder.

parse_date(value)

  Parsar en sträng och returnerar en `datetime.date`.

parse_time(value)

  Analyserar en sträng och returnerar en `datetime.time`.

  UTC-offsets stöds inte; om `värde` beskriver ett sådant är resultatet `None`.

parse_datetime(value)

  Analyserar en sträng och returnerar en `datetime.datetime`.

  UTC-offset stöds; om `värde` beskriver en sådan, är resultatets `tzinfo`-attribut en `datetime.timezone`-instans.

parse_duration(value)

  Parsar en sträng och returnerar en `datetime.timedelta`.

  Förväntar sig data i formatet `"DD HH:MM:SS.uuuuuu"`, `"DD HH:MM:SS,uuuuuu"`, eller som anges av ISO 8601 (t.ex. `P4DT1H15M20S` som motsvarar `4 1:15:20`) eller PostgreSQLs dag-tidsintervallformat (t.ex. `3 dagar 04:05:06`).

  Years and months not supported

  ISO 8601 years (`Y`) and months (`M`) are unsupported as they cannot be represented by `timedelta`.

  Changed in Django 6.1:

  ISO 8601 duration parsing now supports weeks (`PnW`).

## `django.utils.dekoratorer`

method_decorator(decorator, name='')

  Konverterar en funktionsdekorator till en metoddekorator. Den kan användas för att dekorera metoder eller klasser; i det senare fallet är `name` namnet på den metod som ska dekoreras och är obligatoriskt.

  `decorator` kan också vara en lista eller en tupel av funktioner. De paketeras i omvänd ordning så att anropsordningen är den ordning i vilken funktionerna visas i listan/tupeln.

  Se Dekorera klassbaserade vyer för exempel på användning.

decorator_from_middleware(middleware_class)

  Ger en middleware-klass och returnerar en vydekorator. Detta gör att du kan använda middleware-funktionalitet per vy. Mellanvaran skapas utan att några parametrar skickas med.

  Det förutsätter mellanprogram som är kompatibla med den gamla stilen i Django 1.9 och tidigare (med metoder som `process_request()`, `process_exception()` och `process_response()`).

decorator_from_middleware_with_args(middleware_class)

  Som `decorator_from_middleware`, men returnerar en funktion som accepterar de argument som ska skickas till middleware_class. Till exempel: skapas `cache_page()`-dekoratorn från `CacheMiddleware` så här:

      cache_page = decorator_from_middleware_with_args(CacheMiddleware)

      @cache_page(3600)
      def my_view(request):
          pass

sync_only_middleware(middleware)

  Markerar en mellanvara som synkron endast. (Standard i Django, men detta gör att du kan framtidssäkra om standard någonsin ändras i en framtida version)

async_only_middleware(middleware)

  Markerar ett mellanprogram som endast asynkront. Django kommer att linda in den i en asynkron händelseslinga när den anropas från WSGI-begärandesökvägen.

sync_and_async_middleware(middleware)

  Markerar en mellanvara som sync och async kompatibel, detta gör att man kan undvika att konvertera förfrågningar. Du måste implementera detektering av den aktuella förfrågningstypen för att använda denna dekorator. Se dokumentation för asynkrona mellanprogram för detaljer.

## `django.utils.encoding`

smart_str(s, encoding='utf-8', strings_only=False, errors='strict')

  Returnerar ett `str`-objekt som representerar ett godtyckligt objekt `s`. Behandlar bytestrings med hjälp av codec `encoding`.

  Om `strings_only` är `True`, konvertera inte (vissa) icke strängliknande objekt.

is_protected_type(obj)

  Avgör om objektinstansen är av en skyddad typ.

  Objekt av skyddade typer bevaras som de är när de skickas till `force_str(strings_only=True)`.

force_str(s, encoding='utf-8', strings_only=False, errors='strict')

  Liknar `smart_str()`, förutom att lata instanser löses upp till strängar i stället för att behållas som lata objekt.

  Om `strings_only` är `True`, konvertera inte (vissa) icke strängliknande objekt.

smart_bytes(s, encoding='utf-8', strings_only=False, errors='strict')

  Returnerar en bytestringversion av godtyckligt objekt `s`, kodat enligt specifikationen i `encoding`.

  Om `strings_only` är `True`, konvertera inte (vissa) icke strängliknande objekt.

force_bytes(s, encoding='utf-8', strings_only=False, errors='strict')

  Liknar `smart_bytes`, förutom att lata instanser löses upp till bytestrings, i stället för att behållas som lata objekt.

  Om `strings_only` är `True`, konvertera inte (vissa) icke strängliknande objekt.

iri_to_uri(iri)

  Konvertera en IRI-del (Internationalized Resource Identifier) till en URI-del som är lämplig att inkludera i en URL.

  Detta är algoritmen från avsnitt 3.1 i RFC 3987 Section 3.1, något förenklad eftersom indata antas vara en sträng snarare än en godtycklig byteström.

  Tar emot en IRI (sträng eller UTF-8-byte) och returnerar en sträng som innehåller det kodade resultatet.

uri_to_iri(uri)

  Konverterar en enhetlig resursidentifierare till en internationaliserad resursidentifierare.

  Detta är en algoritm från avsnitt 3.2 i RFC 3987 Section 3.2.

  Tar emot en URI i ASCII-bytes och returnerar en sträng som innehåller det kodade resultatet.

filepath_to_uri(path)

  Konverterar en filsystemssökväg till en URI-del som är lämplig att inkludera i en URL. Sökvägen antas vara antingen UTF-8-byte, sträng eller en `Path`.

  This method will encode certain characters that would normally be recognized as special characters for URIs. Note that this method does not encode the ’ character, as it is a valid character within URIs. See `encodeURIComponent()` JavaScript function for more details.

  Returnerar en ASCII-sträng som innehåller det kodade resultatet.

escape_uri_path(path)

  Escapar de osäkra tecknen från sökvägsdelen av en URI (Uniform Resource Identifier).

## `django.utils.feedgenerator`

Exempel på användning:

    >>> from django.utils import feedgenerator
    >>> feed = feedgenerator.Rss201rev2Feed(
    ...     title="Poynter E-Media Tidbits",
    ...     link="https://www.poynter.org/tag/e-media-tidbits/",
    ...     description="A group blog by the sharpest minds in online media/journalism/publishing.",
    ...     language="en",
    ... )
    >>> feed.add_item(
    ...     title="Hello",
    ...     link="https://www.holovaty.com/test/",
    ...     description="Testing.",
    ... )
    >>> with open("test.rss", "w") as fp:
    ...     feed.write(fp, "utf-8")
    ...

För att förenkla valet av en generator används `feedgenerator.DefaultFeed` som för närvarande är `Rss201rev2Feed`

For definitions of the different versions of RSS, see The myth of RSS compatibility.

get_tag_uri(url, date)

  Skapar en TagURI.

  See How to make a good ID in Atom.

### `Stylesheet`

class Stylesheet(url, mimetype='', media='screen')

  Representerar en RSS-formatmall.

  url

    Obligatoriskt argument. Den URL där stilmallen finns.

  mimetype

    An optional string containing the MIME type of the stylesheet. If not specified, Django will attempt to guess it by using Python’s `mimetypes.guess_type()`. Use `mimetype=None` if you don’t want your stylesheet to have a MIME type specified.

  media

    En valfri sträng som kommer att användas som `media`-attribut i stilmallen. Standard är `"screen"`. Använd `media=None` om du inte vill att din stilmall ska ha ett `media`-attribut.

### `SyndicationFeed`

class SyndicationFeed

  Basklass för alla syndikeringsflöden. Underklasser bör tillhandahålla `write()`.

  __init__(title, link, description, language=None, author_email=None, author_name=None, author_link=None, subtitle=None, categories=None, feed_url=None, feed_copyright=None, feed_guid=None, ttl=None, stylesheets=None, **kwargs)

    Initiera flödet med den angivna ordlistan med metadata, som gäller för hela flödet.

    Eventuella extra nyckelordsargument som du skickar till `__init__` kommer att lagras i `self.feed`.

    Alla parametrar ska vara strängar, utom två:

    - `categories` ska vara en sekvens av strängar.

    - `stylesheets` bör vara en sekvens av antingen strängar eller `Stylesheet`-instanser.

  add_item(title, link, description, author_email=None, author_name=None, author_link=None, pubdate=None, comments=None, unique_id=None, categories=(), item_copyright=None, ttl=None, updateddate=None, enclosures=None, **kwargs)

    Lägger till ett objekt i flödet. Alla args förväntas vara strängar utom `pubdate` och `updateddate`, som är `datetime.datetime`-objekt, och `enclosures`, som är en lista över `Enclosure`-instanser.

  num_items()
  root_attributes()

    Returnerar extra attribut att placera på rotelementet (dvs. feed/channel). Anropas från `write()`.

  add_root_elements(handler)

    Lägger till element i rotelementet (dvs. feed/channel). Anropas från `write()`.

  add_stylesheets(self, handler)

    Lägger till information om formatmallar i dokumentet. Anropas från `write()`.

  item_attributes(item)

    Returnerar extra attribut som ska placeras på varje element (t.ex. item/entry).

  add_item_elements(handler, item)

    Lägg till element på varje element för objekt (t.ex. objekt/post).

  write(outfile, encoding)

    Matar ut flödet i den angivna kodningen till `outfile`, som är ett filliknande objekt. Underklasser bör åsidosätta detta.

  writeString(encoding)

    Returnerar matningen i den angivna kodningen som en sträng.

  latest_post_date()

    Returnerar det senaste `pubdate` eller `updateddate` för alla artiklar i flödet. Om inga objekt har något av dessa attribut returneras aktuellt UTC-datum/tid.

### `Hölje`

class Enclosure

  Representerar en RSS-kapsling

### `RssFeed`

class RssFeed(SyndicationFeed)

### `Rss201rev2Feed`

class Rss201rev2Feed(RssFeed)

  Spec: https://cyber.harvard.edu/rss/rss.html

### `RssUserland091Feed`

class RssUserland091Feed(RssFeed)

  Spec: http://backend.userland.com/rss091

### `Atom1Feed`

class Atom1Feed(SyndicationFeed)

  Spec: RFC 4287

## `django.utils.functional`

class cached_property(func)

  Dekoratorn `@cached_property` cachar resultatet av en metod med ett enda `self`-argument som en egenskap. Det cachade resultatet kommer att finnas kvar så länge som instansen gör det, så om instansen skickas runt och funktionen därefter anropas kommer det cachade resultatet att returneras.

  Tänk på ett typiskt fall där en vy kan behöva anropa en modellmetod för att utföra en beräkning, innan modellinstansen placeras i kontexten, där mallen kan anropa metoden en gång till:

      # the model
      class Person(models.Model):
          def friends(self):
              # expensive computation
              ...
              return friends

      # in the view:
      if person.friends():
          ...

  Och i mallen skulle du ha:

      {% for friend in person.friends %}

  Här kommer `friends()` att anropas två gånger. Eftersom instansen `person` i vyn och mallen är densamma kan man undvika detta genom att dekorera `friends()`-metoden med `@cached_property`:

      from django.utils.functional import cached_property

      class Person(models.Model):
          @cached_property
          def friends(self): ...

  Observera att eftersom metoden nu är en egenskap, måste den i Python-koden nås på lämpligt sätt:

      # in the view:
      if person.friends:
          ...

  Det cachade värdet kan behandlas som ett vanligt attribut för instansen:

      # clear it, requiring re-computation next time it's called
      person.__dict__.pop("friends", None)

      # set a value manually, that will persist on the instance until cleared
      person.friends = ["Huckleberry Finn", "Tom Sawyer"]

  Because of the way the descriptor protocol works, using `del` (or `delattr`) on a `cached_property` that hasn’t been accessed raises `AttributeError`.

  Förutom att erbjuda potentiella prestandafördelar kan `@cached_property` säkerställa att ett attributs värde inte ändras oväntat under en instants livstid. Detta kan inträffa med en metod vars beräkning baseras på `datetime.now()`, eller om en ändring sparas i databasen av någon annan process under det korta intervallet mellan efterföljande anrop av en metod på samma instans.

  Du kan skapa cachade egenskaper för metoder. Om du till exempel har en dyr metod `get_friends()` och vill tillåta att den anropas utan att hämta det cachade värdet, kan du skriva:

      friends = cached_property(get_friends)

  Medan `person.get_friends()` räknar om vännerna vid varje anrop, kommer värdet på den cachade egenskapen att kvarstå tills du tar bort den enligt beskrivningen ovan:

      x = person.friends  # calls first time
      y = person.get_friends()  # calls again
      z = person.friends  # does not call
      x is z  # is True

class classproperty(method=None)

  Similar to `@classmethod`, the `@classproperty` decorator converts the result of a method with a single `cls` argument into a property that can be accessed directly from the class.

keep_lazy(func, *resultclasses)

  Django erbjuder många verktygsfunktioner (särskilt i `django.utils`) som tar en sträng som sitt första argument och gör något med den strängen. Dessa funktioner används av mallfilter såväl som direkt i annan kod.

  Om du skriver dina egna liknande funktioner och hanterar översättningar kommer du att ställas inför problemet med vad du ska göra när det första argumentet är ett lazy translation-objekt. Du vill inte konvertera det till en sträng omedelbart, eftersom du kanske använder den här funktionen utanför en vy (och därmed kommer den aktuella trådens locale-inställning inte att vara korrekt).

  För fall som detta kan du använda dekoratorn `django.utils.functional.keep_lazy()`. Den modifierar funktionen så att om den anropas med en lat översättning som ett av sina argument, fördröjs funktionsutvärderingen tills den behöver konverteras till en sträng.

  Till exempel:

      from django.utils.functional import keep_lazy, keep_lazy_text

      def fancy_utility_function(s, *args, **kwargs):
          # Do some conversion on string 's'
          ...

      fancy_utility_function = keep_lazy(str)(fancy_utility_function)

      # Or more succinctly:
      @keep_lazy(str)
      def fancy_utility_function(s, *args, **kwargs): ...

  Dekoratorn `keep_lazy()` tar ett antal extra argument (`*args`) som specificerar den eller de typer som den ursprungliga funktionen kan returnera. Ett vanligt användningsfall är att ha funktioner som returnerar text. För dessa kan du skicka typen `str` till `keep_lazy` (eller använda dekoratorn `keep_lazy_text()` som beskrivs i nästa avsnitt).

  Med hjälp av den här dekoratorn kan du skriva din funktion och anta att indata är en korrekt sträng, och sedan lägga till stöd för lata översättningsobjekt i slutet.

keep_lazy_text(func)

  En genväg till `keep_lazy(str)(func)`.

  Om du har en funktion som returnerar text och du vill kunna ta lata argument medan du fördröjer utvärderingen av dem, kan du använda denna dekorator:

      from django.utils.functional import keep_lazy, keep_lazy_text

      # Our previous example was:
      @keep_lazy(str)
      def fancy_utility_function(s, *args, **kwargs): ...

      # Which can be rewritten as:
      @keep_lazy_text
      def fancy_utility_function(s, *args, **kwargs): ...

## `django.utils.html`

Vanligtvis bör du bygga upp HTML med hjälp av Djangos mallar för att använda dess autoescape-mekanism, med hjälp av verktygen i `django.utils.safestring` där det är lämpligt. Denna modul tillhandahåller några ytterligare verktyg på låg nivå för att escapa HTML.

escape(text)

  Returnerar den angivna texten med ampersand, citattecken och vinkelparenteser kodade för användning i HTML. Inmatningen är först tvingad till en sträng och utmatningen har `mark_safe()` tillämpad.

conditional_escape(text)

  Similar to `escape()`, except that it doesn’t operate on pre-escaped strings, so it will not double escape.

format_html(format_string, *args, **kwargs)

  Detta liknar `str.format()`, förutom att det är lämpligt för att bygga upp HTML-fragment. Det första argumentet `format_string` escapas inte men alla andra args och kwargs passerar genom `conditional_escape()` innan de skickas till `str.format()`. Slutligen har utdata `mark_safe()` tillämpats.

  När det gäller att bygga upp små HTML-fragment är den här funktionen att föredra framför stränginterpolering med hjälp av `%` eller `str.format()` direkt, eftersom den tillämpar escaping på alla argument - precis som mallsystemet tillämpar escaping som standard.

  Så istället för att skriva:

      mark_safe(
          "%s <b>%s</b> %s"
          % (
              some_html,
              escape(some_text),
              escape(some_other_text),
          )
      )

  Du bör istället använda:

      format_html(
          "{} <b>{}</b> {}",
          mark_safe(some_html),
          some_text,
          some_other_text,
      )

  Detta har fördelen att du inte behöver tillämpa `escape()` på varje argument och riskera en bugg och en XSS-sårbarhet om du glömmer bort ett.

  Observera att även om denna funktion använder `str.format()` för att göra interpoleringen, kommer några av formateringsalternativen som tillhandahålls av `str.format()` (t.ex. nummerformatering) inte att fungera, eftersom alla argument skickas genom `conditional_escape()` som (i slutändan) anropar `force_str()` på värdena.

format_html_join(sep, format_string, args_generator)

  En omslutning av `format_html()`, för det vanliga fallet med en grupp argument som behöver formateras med samma formatsträng och sedan sammanfogas med `sep`. `sep` skickas också genom `conditional_escape()`.

  `args_generator` bör vara en iterator som ger argument att skicka till `format_html()`, antingen sekvenser av positionella argument eller mappningar av nyckelordsargument.

  Tupler kan till exempel användas för positionella argument:

      format_html_join(
          "\n",
          "<li>{} {}</li>",
          ((u.first_name, u.last_name) for u in users),
      )

  Eller så kan ordböcker användas för nyckelordsargument:

      format_html_join(
          "\n",
          '<li data-id="{id}">{id} {title}</li>',
          ({"id": b.id, "title": b.title} for b in books),
      )

json_script(value, element_id=None, encoder=None)

  Escapar alla HTML/XML-specialtecken med deras Unicode-escape, så att värdet är säkert för användning med JavaScript. Omsluter också den undangömda JSON i en `<script>` tagg. Om parametern `element_id` inte är `None` får taggen `<script>` det angivna id:t. Till exempel:

      >>> json_script({"hello": "world"}, element_id="hello-data")
      '<script id="hello-data" type="application/json">{"hello": "world"}</script>'

  `encoder`, som som standard är `django.core.serializers.json.DjangoJSONEncoder`, kommer att användas för att serialisera data. Se JSON serialization för mer information om denna serialiserare.

strip_tags(value)

  Försöker ta bort allt som ser ut som en HTML-tagg från strängen, det vill säga allt som finns inom `<>`.

  Absolut INGEN garanti ges för att den resulterande strängen är HTML-säker. Så markera ALDRIG resultatet av ett `strip_tags`-anrop som säkert utan att först escapa det, till exempel med `escape()`.

  Till exempel:

      strip_tags(value)

  Om `value` är `<b>"Joel</b> <button>is</button> a <span>slug</span>"` kommer returvärdet att vara `"Joel is a slug"`.

  Om du letar efter en mer robust lösning kan du överväga att använda ett HTML-rensningsverktyg från tredje part.

html_safe()

  Metoden `__html__()` på en klass hjälper icke-Django-mallar att upptäcka klasser vars utdata inte kräver HTML-escaping.

  Denna dekorator definierar metoden `__html__()` på den dekorerade klassen genom att omsluta `__str__()` i `mark_safe()`. Säkerställ att metoden `__str__()` verkligen returnerar text som inte kräver HTML-escape.

## `django.utils.http`

urlencode(query, doseq=False)

  En version av Pythons `urllib.parse.urlencode()`-funktion som kan arbeta med `MultiValueDict` och värden som inte är strängar.

http_date(epoch_seconds=None)

  Formaterar tiden så att den matchar datumformatet RFC 1123 Section 5.2.14 som anges av HTTP RFC 9110 Section 5.6.7.

  Accepterar ett flyttal uttryckt i sekunder sedan epoken i UTC - såsom det som matas ut av `time.time()`. Om inställningen är `None`, är standardvärdet den aktuella tiden.

  Utmatning av en sträng i formatet `Wdy, DD Mon YYYY HH:MM:SS GMT`.

content_disposition_header(as_attachment, filename)

  Konstruerar ett HTTP-huvudvärde för `Content-Disposition` från det givna `filnamnet` enligt specifikationen i RFC 6266. Returnerar `None` om `as_attachment` är `False` och `filnamn` är `None`, annars returneras en sträng som passar för HTTP-huvudet `Content-Disposition`.

base36_to_int(s)

  Konverterar en bas 36-sträng till ett heltal.

int_to_base36(i)

  Konverterar ett positivt heltal till en bas 36-sträng.

urlsafe_base64_encode(s)

  Kodar en bytestring till en base64-sträng för användning i URL:er och tar bort eventuella efterföljande likhetstecken.

urlsafe_base64_decode(s)

  Avkodar en base64-kodad sträng och lägger tillbaka eventuella efterföljande likhetstecken som kan ha tagits bort.

## `django.utils.module_loading`

Funktioner för att arbeta med Python-moduler.

import_string(dotted_path)

  Importerar en prickad modulväg och returnerar det attribut/den klass som anges med det sista namnet i sökvägen. Anger `ImportError` om importen misslyckades. Till exempel:

      from django.utils.module_loading import import_string

      ValidationError = import_string("django.core.exceptions.ValidationError")

  är likvärdig med:

      from django.core.exceptions import ValidationError

## `django.utils.safestring`

Funktioner och klasser för att arbeta med ”säkra strängar”: strängar som kan visas säkert utan ytterligare escaping i HTML. Att markera något som en ”säker sträng” innebär att producenten av strängen redan har förvandlat tecken som inte bör tolkas av HTML-motorn (t.ex. ’<’) till lämpliga enheter.

class SafeString

  En `str`-underklass som särskilt har markerats som ”säker” (kräver ingen ytterligare escaping) för HTML-utdata.

mark_safe(s)

  Markera uttryckligen en sträng som säker för (HTML-)utdata. Det returnerade objektet kan användas överallt där en sträng är lämplig.

  Kan anropas flera gånger på en och samma sträng.

  Kan också användas som dekorationsmaterial.

  För att bygga upp fragment av HTML bör du normalt använda `django.utils.html.format_html()` istället.

  En sträng som är markerad som säker blir osäker igen om den ändras. Till exempel:

      >>> mystr = "<b>Hello World</b>   "
      >>> mystr = mark_safe(mystr)
      >>> type(mystr)
      <class 'django.utils.safestring.SafeString'>

      >>> mystr = mystr.strip()  # removing whitespace
      >>> type(mystr)
      <type 'str'>

## `django.utils.text`

format_lazy(format_string, *args, **kwargs)

  En version av `str.format()` för när `format_string`, `args` och/eller `kwargs` innehåller lata objekt. Det första argumentet är den sträng som ska formateras. Till exempel:

      from django.utils.text import format_lazy
      from django.utils.translation import pgettext_lazy

      urlpatterns = [
          path(
              format_lazy("{person}/<int:pk>/", person=pgettext_lazy("URL", "person")),
              PersonDetailView.as_view(),
          ),
      ]

  Detta exempel tillåter översättare att översätta en del av URL:en. Om ”person” översätts till ”persona” kommer det reguljära uttrycket att matcha `persona/(?P<pk>\d+)/$`, t.ex. `persona/5/`.

slugify(value, allow_unicode=False)

  Konverterar en sträng till en URL-slog genom:

  1. Konverterar till ASCII om `allow_unicode` är `False` (standard).

  2. Konvertering till gemener.

  3. Ta bort tecken som inte är alfanumeriska, understreck, bindestreck eller blanksteg.

  4. Ersätter alla blanksteg eller upprepade streck med enkla streck.

  5. Ta bort inledande och avslutande blanksteg, bindestreck och understrykningstecken.

  Till exempel:

      >>> slugify(" Joel is a slug ")
      'joel-is-a-slug'

  Om du vill tillåta Unicode-tecken ska du ange `allow_unicode=True`. Ett exempel:

      >>> slugify("你好 World", allow_unicode=True)
      '你好-world'

## `django.utils.timezone`

get_fixed_timezone(offset)

  Returnerar en `tzinfo`-instans som representerar en tidszon med en fast förskjutning från UTC.

  `offset` är en `datetime.timedelta` eller ett heltal i minuter. Använd positiva värden för tidszoner öster om UTC och negativa värden för väster om UTC.

get_default_timezone()

  Returnerar en `tzinfo`-instans som representerar standardtidszonen.

get_default_timezone_name()

  Returnerar namnet på standardtidszon.

get_current_timezone()

  Returnerar en `tzinfo`-instans som representerar aktuell tidszon.

get_current_timezone_name()

  Returnerar namnet på aktuell tidszon.

activate(timezone)

  Ställer in aktuell tidszon. Argumentet `timezone` måste vara en instans av en `tzinfo`-underklass eller ett namn på en tidszon.

deactivate()

  Återställer aktuell tidszon.

override(timezone)

  This is a Python context manager that sets the current time zone on entry with `activate()`, and restores the previously active time zone on exit. If the `timezone` argument is `None`, the current time zone is unset on entry with `deactivate()` instead.

  `override` kan också användas som en funktionsdekorator.

localtime(value=None, timezone=None)

  Konverterar en medveten `datetime` till en annan tidszon, som standard aktuell tidszon.

  När `value` utelämnas, är standardvärdet `now()`.

  Den här funktionen fungerar inte på naiva datatider; använd `make_aware()` istället.

localdate(value=None, timezone=None)

  Använder `localtime()` för att konvertera en medveten `datetime` till en `date()` i en annan tidszon, som standard aktuell tidszon.

  När `value` utelämnas, är standardvärdet `now()`.

  Denna funktion fungerar inte på naiva datatider.

now()

  Returnerar en `datetime` som representerar den aktuella tidpunkten. Exakt vad som returneras beror på värdet av `USE_TZ`:

  - Om `USE_TZ` är `False`, kommer detta att vara en naive datatid (dvs. en datatid utan en associerad tidszon) som representerar den aktuella tiden i systemets lokala tidszon.

  - Om `USE_TZ` är `True`, kommer detta att vara en aware datatid som representerar den aktuella tiden i UTC. Observera att `now()` alltid kommer att returnera tider i UTC oavsett värdet på `TIME_ZONE`; du kan använda `localtime()` för att få tiden i den aktuella tidszonen.

is_aware(value)

  Returnerar `True` om `value` är medveten, `False` om den är naiv. Denna funktion förutsätter att `value` är en `datetime`.

is_naive(value)

  Returnerar `True` om `value` är naivt, `False` om det är medvetet. Denna funktion förutsätter att `value` är en `datetime`.

make_aware(value, timezone=None)

  Returnerar en medveten `datetime` som representerar samma tidpunkt som `value` i `timezone`, `value` är en naiv `datetime`. Om `timezone` är satt till `None`, är standardvärdet aktuell tidszon.

make_naive(value, timezone=None)

  Returnerar en naiv `datetime` som representerar i `timezone` samma tidpunkt som `value`, `value` är en medveten `datetime`. Om `timezone` är satt till `None`, är standardvärdet aktuell tidszon.

## `django.utils.översättning`

För en fullständig diskussion om användningen av följande, se Översättningsdokumentation.

gettext(message)

  Översätter `message` och returnerar det som en sträng.

pgettext(context, message)

  Översätter `message` givet `context` och returnerar det som en sträng.

  För mer information, se Kontextuella markörer.

gettext_lazy(message)

pgettext_lazy(context, message)

  Samma sak som de icke-lata versionerna ovan, men med lat utförande.

  Se dokumentation för lättsamma översättningar.

gettext_noop(message)

  Markerar strängar för översättning men översätter dem inte nu. Detta kan användas för att lagra strängar i globala variabler som bör förbli på basspråket (eftersom de kan användas externt) och som kommer att översättas senare.

ngettext(singular, plural, number)

  Översätter `ingular` och `plural` och returnerar lämplig sträng baserat på `number`.

npgettext(context, singular, plural, number)

  Översätter `ingular` och `plural` och returnerar lämplig sträng baserat på `number` och `context`.

ngettext_lazy(singular, plural, number)

npgettext_lazy(context, singular, plural, number)

  Samma sak som de icke-lata versionerna ovan, men med lat utförande.

  Se dokumentation för lättsamma översättningar.

activate(language)

  Hämtar översättningsobjektet för ett visst språk och aktiverar det som det aktuella översättningsobjektet för den aktuella tråden.

deactivate()

  Avaktiverar det aktiva översättningsobjektet så att ytterligare _-anrop kommer att lösas mot standardöversättningsobjektet igen.

deactivate_all()

  Gör det aktiva översättningsobjektet till en `NullTranslations()`-instans. Detta är användbart när vi av någon anledning vill att försenade översättningar ska visas som originalsträngen.

override(language, deactivate=False)

  En Python-kontexthanterare som använder `django.utils.translation.activate()` för att hämta översättningsobjektet för ett visst språk, aktiverar det som översättningsobjekt för den aktuella tråden och återaktiverar det tidigare aktiva språket vid avslut. Eventuellt kan den avaktivera den tillfälliga översättningen vid avslut med `django.utils.translation.deactivate()` om argumentet `deactivate` är `True`. Om du skickar `None` som språkargument aktiveras en `NullTranslations()`-instans inom kontexten.

  `override` kan också användas som en funktionsdekorator.

check_for_language(lang_code)

  Kontrollerar om det finns en global språkfil för den angivna språkkoden (t.ex. ’fr’, ’pt_BR’). Detta används för att avgöra om ett användartillhandahållet språk är tillgängligt.

  `lang_code` has a maximum accepted length of 500 characters. `False` is returned if it exceeds this limit, before any language-file lookup.

get_language()

  Returns the currently selected language code. Returns `None` if translations are temporarily deactivated (by `deactivate_all()` or when `None` is passed to `override()`).

get_language_bidi()

  Returnerar det valda språkets BiDi-layout:

  - `False` = layout från vänster till höger

  - `True` = höger till vänster-layout

get_language_from_request(request, check_path=False)

  Analyserar begäran för att ta reda på vilket språk användaren vill att systemet ska visa. Endast språk som listas i settings.LANGUAGES beaktas. Om användaren begär ett underspråk där vi har ett huvudspråk, skickar vi ut huvudspråket.

  Om `check_path` är `True` kontrollerar funktionen först om sökvägen till den begärda URL:en börjar med en språkkod som anges i inställningen `LANGUAGES`.

get_supported_language_variant(lang_code, strict=False)

  Returnerar `lang_code` om den finns i inställningen `LANGUAGES`, och väljer eventuellt en mer generisk variant. Till exempel: returneras `'es'` om `lang_code` är `'es-ar'` och `'es'` finns i `LANGUAGES` men `'es-ar'` inte gör det.

  `lang_code` har en maximal accepterad längd på 500 tecken. Ett `LookupError` uppstår om `lang_code` överskrider denna gräns och `strict` är `True`, eller om det inte finns någon generisk variant och `strict` är `False`.

  Om `strict` är `False` (standard), kan en landsspecifik variant returneras när varken språkkoden eller dess generiska variant hittas. Om till exempel endast `'es-co'` finns i `LANGUAGES`, returneras det för `lang_code` som `es'` och `'es-ar'`. Dessa matchningar returneras inte om `strict=True`.

  Utlöser `LookupError` om inget hittas.

to_locale(language)

  Omvandlar ett språknamn (en-us) till ett lokalt namn (en_US).

templatize(src)

  Förvandlar en Django-mall till något som förstås av `xgettext`. Det gör det genom att översätta Django-översättningstaggarna till standard `gettext`-funktionsinbjudningar.