Ce document présente tous les modules stables dans django.utils. La plupart des modules dans django.utils sont conçus pour un usage interne et seuls les parties documentées ici peuvent être considérées comme stables et donc rétrocompatibles, selon la politique interne d’obsolescence de publication.
django.utils.cacheLien vers cette rubrique#Ce module contient des fonctions utilitaires pour le contrôle du cache. Il opère en manipulant l’en-tête Vary des réponses. Il contient des fonctions pour modifier directement l’en-tête des objets réponse ainsi que des décorateurs qui modifient les fonctions afin qu’elle se chargent elles-mêmes de la modification des en-têtes.
Pour plus d’informations sur l’en-tête Vary, voir la RFC 7231 Section 7.1.4.
À la base, l’en-tête HTTP Vary définit quels en-têtes de requête un cache doit prendre en considération pour générer sa clé de cache. Les requêtes vers un même chemin mais contenant des contenus d’en-tête différents pour les en-têtes mentionnés dans Vary ont besoin de produire des clés de cache différentes pour ne pas délivrer de mauvais contenu.
Par exemple, l’intergiciel d”internationalisation doit pouvoir mettre en cache des versions différentes en fonction de l’en-tête Accept-language.
Cette fonction complète l’en-tête Cache-Control en y ajoutant tous les paramètres nommés. La transformation se fait comme suit :
Tous les paramètres nommés sont transformés en minuscules et les soulignements sont convertis en tirets.
Si la valeur d’un paramètre est True (exactement True, pas seulement une valeur évaluée à True), seul le nom du paramètre est ajouté à l’en-tête.
Tous les autres paramètres sont ajoutés avec leur valeur, après avoir passé par la fonction str().
Renvoie la valeur max-age de l’en-tête de réponse Cache-Control sous forme de nombre entier (ou None s’il n’existe pas ou qu’il n’est pas un nombre entier).
Ajoute certains en-têtes utiles à l’objet HttpResponse donné :
ETag
Expires
Cache-Control
Chaque en-tête n’est ajouté que s’il n’est pas déjà présent.
\ncache_timeout est en secondes. Le réglage CACHE_MIDDLEWARE_SECONDS est utilisé par défaut.
Ajoute un en-tête Cache-Control: max-age=0, no-cache, no-store, must-revalidate à une réponse pour indiquer que la page ne doit jamais être mise en cache.
Ajoute (ou met à jour) l’en-tête Vary dans l’objet HttpResponse donné. newheaders est une liste de noms d’en-têtes qui doivent se trouver dans Vary. Les en-têtes existants dans Vary ne sont pas enlevés.
Renvoie une clé de cache basée sur le chemin de requête. Cette méthode peut être utilisée dans la phase de requête car elle extrait la liste d’en-têtes à prendre en compte à partir du registre global de chemin et utilise ces en-têtes pour construire une clé de cache à utiliser.
\nSi aucune liste d’en-tête n’est stockée, la page doit être reconstruite et cette fonction renvoie donc None.
Apprend quels en-têtes à prendre en compte pour un certain chemin de requête à partir de l’objet réponse. Elle stocke ces en-têtes dans un registre global de chemins afin que tout accès ultérieur à ce chemin sache les en-têtes à prendre en compte sans devoir construire l’objet réponse lui-même. Les en-têtes sont nommés dans l’en-tête Vary de la réponse, mais il s’agit d’éviter de devoir générer la réponse.
La liste des en-têtes à utiliser pour la génération de la clé de cache est stockée dans le même cache que les pages elles-mêmes. Si le cache rejette certaines vieilles données du cache, cela signifie simplement qu’il faut reconstruire une fois la réponse pour avoir accès à l’en-tête Vary et par là à la liste des en-têtes à utiliser pour la clé de cache.
django.utils.dateparseLien vers cette rubrique#Les fonctions définies dans ce module partagent les propriétés suivantes :
\nElles génèrent une exception ValueError si la valeur d’entrée est correctement mise en forme mais qu’elle ne correspond pas à une date ou heure valable.
Elles renvoient None si la valeur d’entrée n’est pas correctement mise en forme.
Elles acceptent une résolution de valeur d’entrée jusqu’à la picoseconde, mais elles tronquent à la microseconde car c’est la résolution maximale gérée par Python.
Analyse une chaîne et renvoie un objet datetime.date.
Analyse une chaîne et renvoie un objet datetime.time.
Les décalages UTC ne sont pas pris en charge ; si value en contient un, le résultat sera None.
Analyse une chaîne et renvoie un objet datetime.datetime.
Les décalages UTC sont pris en charge ; si value en contient un, l’attribut tzinfo du résultat sera une instance FixedOffset.
Analyse une chaîne et renvoie un objet datetime.timedelta.
S’attend à recevoir des données au format "JJ HH:MM:SS.uuuuuu" ou tel que défini par ISO 8601 (par ex. P4DT1H15M20S ce qui est équivalent à 4 1:15:20).
django.utils.decoratorsLien vers cette rubrique#Convertit un décorateur de fonction en un décorateur de méthode. Cette fonction peut être utilisée pour décorer des méthodes ou des classes ; dans ce dernier cas, name est le nom de la méthode à décorer et est obligatoire.
decorator peut aussi être une liste ou un tuple de fonctions. Celles-ci sont décorées dans l’ordre inverse, ce qui fait que l’ordre d’appel est le même que celui dans lequel les fonctions apparaissent dans la liste.
Voir décoration des vues fondées sur les classes pour un exemple d’utilisation.
\nRenvoie un décorateur de vue à partir d’une classe d’intergiciel. Cela permet d’utiliser des fonctionnalités d’intergiciel pour certaines vues seulement. L’intergiciel est créé sans aucun paramètre.
\nIl s’attend à des intergiciels compatibles avec l’ancien style de Django jusqu’à 1.9 (en ayant des méthodes comme process_request(), process_exception() et process_response()).
Comme decorator_from_middleware, mais renvoie une fonction qui accepte des paramètres à transmettre à la classe middleware_class. Par exemple, le décorateur cache_page() est créé à partir de CacheMiddleware comme ceci :
cache_page = decorator_from_middleware_with_args(CacheMiddleware)\n\n@cache_page(3600)\ndef my_view(request):\n pass\ndjango.utils.encodingLien vers cette rubrique#Un décorateur qui définit les méthodes __unicode__ et __str__ avec Python 2. Avec Python 3, il ne fait rien.
Pour pouvoir prendre en charge à la fois Python 2 et 3 avec une seule base de code, définissez une méthode __str__ renvoyant du texte (en utilisant six.text_type() si du forçage de type doit avoir lieu) et appliquez ce décorateur à la classe.
Renvoie un objet texte représentant s, c’est-à-dire de type unicode avec Python 2 et de type str avec Python 3. Traite les chaînes d’octets en utilisant le codage encoding.
Si strings_only est True, ne convertit pas certains objets non assimilables à des chaînes.
Nom historique de smart_text(). Seulement disponible avec Python 2.
Détermine si l’instance d’objet est d’un type protégé.
\nLes objets d’un type protégé sont préservés tels quels lorsqu’ils sont transmis à force_text(strings_only=True).
Semblable à smart_text, sauf que les instances différées sont évaluées en chaînes, plutôt que de conserver leur état différé.
Si strings_only est True, ne convertit pas certains objets non assimilables à des chaînes.
Nom historique de force_text(). Seulement disponible avec Python 2.
Renvoie une version de s sous forme de chaîne d’octets, en utilisant le codage indiqué dans encoding.
Si strings_only est True, ne convertit pas certains objets non assimilables à des chaînes.
Semblable à smart_bytes, sauf que les instances différées sont évaluées en chaînes d’octets, plutôt que de conserver leur état différé.
Si strings_only est True, ne convertit pas certains objets non assimilables à des chaînes.
Alias de smart_bytes() avec Python 2 et de smart_text() avec Python 3. Cette fonction renvoie un type str ou une chaîne différée.
Cela convient par exemple à l’écriture vers sys.stdout aussi bien pour Python 2 que Python 3.
Alias de force_bytes() avec Python 2 et de force_text() avec Python 3. Cette fonction renvoie toujours un type str.
Convertit une portion d’identifiant de ressource internationalisé (IRI) en portion d’URI qui convient pour l’inclusion dans une URL.
\nIl s’agit de l’algorithme de la section 3.1 de la RFC 3987 Section 3.1. Cependant, comme nous partons du principe que la valeur d’entrée est déjà soit en UTF-8, soit en unicode, nous pouvons simplifier un peu les choses par rapport à la méthode complète.
\nAccepte une IRI sous forme d’octets UTF-8 et renvoie une chaîne d’octets ASCII contenant le résultat encodé.
\nConvertit une URI (Uniform Resource Identifier) en une IRI (Internationalized Resource Identifier).
\nIl s’agit d’un algorithme inspiré de la section 3.2 de la RFC 3987 Section 3.2.
\nAccepte une URI en octets ASCII et renvoie une chaîne unicode contenant le résultat encodé.
\nConvertit un chemin de système de fichiers en une portion d’URI convenable pour son inclusion dans une URL. Le chemin en entrée doit être soit de l’UTF-8, soit de l’unicode.
\nCette méthode code certains caractères qui sont normalement identifiés comme des caractères spéciaux dans les URI. Notez que cette méthode ne code pas le caractère « “ » car c’est un caractère accepté dans les URI. Voir la fonction JavaScript encodeURIComponent() pour plus de détails.
Renvoie une chaîne ASCII contenant le résultat encodé.
\nÉchappe les caractères non sûrs de la portion de chemin d’un URI (Uniform Resource Identifier).
\ndjango.utils.feedgeneratorLien vers cette rubrique#Exemple d’utilisation :
\n>>> from django.utils import feedgenerator\n>>> feed = feedgenerator.Rss201rev2Feed(\n... title="Poynter E-Media Tidbits",\n... link="http://www.poynter.org/column.asp?id=31",\n... description="A group Weblog by the sharpest minds in online media/journalism/publishing.",\n... language="en",\n... )\n>>> feed.add_item(\n... title="Hello",\n... link="http://www.holovaty.com/test/",\n... description="Testing.",\n... )\n>>> with open('test.rss', 'w') as fp:\n... feed.write(fp, 'utf-8')\nPour simplifier la sélection d’un générateur, utilisez feedgenerator.DefaultFeed qui est actuellement Rss201rev2Feed.
Pour les définitions des différentes versions de RSS, voir https://web.archive.org/web/20110718035220/http://diveintomark.org/archives/2004/02/04/incompatible-rss
\nCrée un TagURI.
Voir https://web.archive.org/web/20110514113830/http://diveintomark.org/archives/2004/05/28/howto-atom-id
\nEnclosureLien vers cette rubrique#Représente une annexe RSS.
\nRssFeedLien vers cette rubrique#Rss201rev2FeedLien vers cette rubrique#Spécification : https://cyber.harvard.edu/rss/rss.html
\nRssUserland091FeedLien vers cette rubrique#Spécification : http://backend.userland.com/rss091
\nAtom1FeedLien vers cette rubrique#Spécification : https://tools.ietf.org/html/rfc4287
\ndjango.utils.functionalLien vers cette rubrique#Le décorateur @cached_property met en cache le résultat d’une méthode ayant un seul paramètre self sous forme de propriété. Le résultat en cache persiste aussi longtemps que l’instance, ce qui fait que si l’instance est conservée et que la fonction est appelée une nouvelle fois plus tard, le résultat en cache est renvoyé.
Considérons un cas typique où une vue a besoin d’appeler la méthode d’un modèle pour effectuer un certain calcul avant de placer cette instance de modèle dans le contexte passé au gabarit, et celui-ci a aussi besoin d’appeler la méthode une nouvelle fois :
\n# the model\nclass Person(models.Model):\n\n def friends(self):\n # expensive computation\n ...\n return friends\n\n# in the view:\nif person.friends():\n ...\nEt dans le gabarit, vous auriez :
\n{% for friend in person.friends %}\nfriends() sera ici appelée deux fois. Puisque les instances person dans la vue et dans le gabarit représentent la même instance, décorer la méthode friends() avec @cached_property permet d’éviter cela
from django.utils.functional import cached_property\n\nclass Person(models.Model):\n\n @cached_property\n def friends(self):\n ...\nNotez que la méthode étant maintenant devenue une propriété, le code Python doit l’invoquer de manière adéquate :
\n# in the view:\nif person.friends:\n ...\nLa valeur en cache peut être traitée comme n’importe quel autre attribut normal de l’instance :
\n# clear it, requiring re-computation next time it's called\ndel person.friends # or delattr(person, "friends")\n\n# set a value manually, that will persist on the instance until cleared\nperson.friends = ["Huckleberry Finn", "Tom Sawyer"]\nEn plus d’offrir des avantages potentiels en terme de performance, @cached_property peut garantir que la valeur d’un attribut ne change pas de manière inattendue au cours de la vie d’une instance. Cela pourrait se produire avec une méthode dont le calcul est basé sur datetime.now(), ou simplement dans le cas où la base de données est modifiée par une autre processus dans le bref intervalle entre des appels successifs d’une méthode de la même instance.
Vous pouvez utiliser le paramètre name pour créer des propriétés en cache pour d’autres méthodes. Par exemple, si vous avez une méthode coûteuse get_friends() et que vous vouliez permettre de l’appeler aussi sans récupérer la valeur en cache, vous pourriez écrire :
friends = cached_property(get_friends, name='friends')\nAlors que person.get_friends() recalcule les amis à chaque appel, la valeur de la propriété en cache persiste tant que vous ne la supprimez pas, comme expliqué ci-dessus :
x = person.friends # calls first time\ny = person.get_friends() # calls again\nz = person.friends # does not call\nx is z # is True\nFonctionne comme keep_lazy() sauf qu’elle ne peut pas être utilisée comme décorateur.
Django offre de nombreuses fonctions utilitaires (particulièrement dans django.utils) qui acceptent une chaîne comme premier paramètre et font quelque chose avec cette chaîne. Ces fonctions sont utilisées aussi bien par des filtres de gabarit que de façon directe dans du code Python.
Si vous écrivez vous-même des fonctions semblables et que vous devez gérer des traductions, vous serez confronté au problème du traitement du premier paramètre quand il s’agit d’un objet de traduction différée. Il n’est pas souhaitable de le convertir immédiatement en chaîne de caractères, car il se peut que cette fonction soit utilisée en dehors d’une vue (et donc que le réglage de langue du fil d’exécution en cours ne soit pas le bon).
\nPour des cas comme celui-là, utilisez le décorateur django.utils.functional.keep_lazy(). Il modifie la fonction afin que si elle est appelée avec en paramètre une traduction différée, l’évaluation de la fonction est reportée jusqu’au moment où il devient vraiment nécessaire de produire une chaîne.
Par exemple :
\nfrom django.utils import six\nfrom django.utils.functional import keep_lazy, keep_lazy_text\n\ndef fancy_utility_function(s, ...):\n # Do some conversion on string 's'\n ...\nfancy_utility_function = keep_lazy(six.text_type)(fancy_utility_function)\n\n# Or more succinctly:\n@keep_lazy(six.text_type)\ndef fancy_utility_function(s, ...):\n ...\nLe décorateur keep_lazy() accepte quelques paramètres supplémentaires (*args) indiquant le ou les types renvoyés par la fonction originale. Un cas d’utilisation fréquent est d’avoir des fonctions qui renvoient du texte. Pour celles-ci, il suffit de passer le type six.text_type à keep_lazy (ou même plus simplement, utilisez le décorateur keep_lazy_text() présenté à la section suivante).
L’emploi de ce décorateur permet d’écrire une fonction et de compter sur la présence d’une vraie chaîne en entrée, puis d’ajouter au final la prise en charge des objets de traduction différée.
\nUn raccourci pour keep_lazy(six.text_type)(func).
Si vous avez une fonction qui renvoie du texte et que vous souhaitez pouvoir accepter des paramètres dont l’évaluation est différée, utilisez simplement ce décorateur :
\nfrom django.utils import six\nfrom django.utils.functional import keep_lazy, keep_lazy_text\n\n# Our previous example was:\n@keep_lazy(six.text_type)\ndef fancy_utility_function(s, ...):\n ...\n\n# Which can be rewritten as:\n@keep_lazy_text\ndef fancy_utility_function(s, ...):\n ...\ndjango.utils.htmlLien vers cette rubrique#En principe, le code HTML doit être construit avec des gabarits Django pour profiter de leur mécanisme d’échappement automatique, en faisant appel aux utilitaires de django.utils.safestring en cas de besoin. Ce module fournit quelques utilitaires supplémentaires de bas niveau pour l’échappement de code HTML.
Renvoie le texte donné en codant les esperluettes, les guillemets et les chevrons de manière adaptée au HTML. Le texte en entrée est d’abord passé dans la fonction force_text() et le résultat final est marqué comme sûr avec mark_safe().
Semblable à escape(), sauf qu’elle n’opère pas sur les chaînes déjà échappées afin d’éviter un double échappement.
Cette fonction ressemble à str.format(), sauf qu’elle est particulièrement appropriée pour la construction de fragments HTML. Tous les paramètres (args/kwargs) passent par conditional_escape() avant d’être transmis à str.format().
Dans les cas où il s’agit de produire des petits fragments HTML, cette fonction doit être préférée à l’interpolation de chaîne directe avec % ou str.format(), car elle applique l’échappement à tous ses paramètres, tout comme le fait le système de gabarit par défaut.
Donc au lieu d’écrire :
\nmark_safe("%s <b>%s</b> %s" % (\n some_html,\n escape(some_text),\n escape(some_other_text),\n))\nIl est préférable d’écrire :
\nformat_html("{} <b>{}</b> {}",\n mark_safe(some_html),\n some_text,\n some_other_text,\n)\nCeci présente l’avantage de ne pas devoir appliquer soi-même escape() à chacun des paramètres et de risquer une anomalie ou une vulnérabilité XSS si on en oublie un.
Notez que bien que cette fonction utilise str.format() pour effectuer l’interpolation, certaines des options de format fournies par str.format() (par ex. les formats de nombre) ne fonctionnent pas, car tous les paramètres sont passés par la moulinette conditional_escape() qui appelle force_text() sur les valeurs reçues.
Une adaptateur de format_html() conçu pour le cas courant d’un groupe de paramètres devant être mis en forme avec la même chaîne de format, puis combinés avec sep. sep passe lui-même aussi par conditional_escape().
args_generator doit être un itérateur renvoyant la liste de paramètres args qui seront transmis à format_html(). Par exemple :
format_html_join(\n '\\n', "<li>{} {}</li>",\n ((u.first_name, u.last_name) for u in users)\n)\nTente de supprimer de la chaîne tout ce qui ressemble à une balise HTML, c’est-à-dire tout ce qui est contenu à l’intérieur de <>.
Il n’y a absolument AUCUNE garantie que la chaîne résultante sera vraiment sûre du point de vue HTML. Il ne faut donc JAMAIS marquer comme sûre le résultat d’un appel à strip_tag sans l’avoir d’abord échappé, par exemple avec escape().
Par exemple :
\nstrip_tags(value)\nSi value vaut "<b>Joël</b> <button>est</button> une <span>limace</span>", la valeur renvoyée sera "Joël est une limace".
Si vous recherchez une solution plus robuste, regardez du côté de la bibliothèque Python bleach.
\nLa méthode __html__() d’une classe aide les gabarits non Django à détecter les classes dont le résultat ne demande pas d’échappement HTML.
Ce décorateur définit la méthode __html__() pour la classe décorée en enveloppant __unicode__() (Python 2) ou __str__() (Python 3) dans mark_safe(). Assurez-vous que la méthode __unicode__() ou __str__() renvoie effectivement du texte qui ne demande pas d’échappement HTML.
django.utils.httpLien vers cette rubrique#Une version de la fonction Python urllib.quote() pouvant agir sur des chaînes Unicode. L’URL est d’abord codée en UTF-8 avant d’être traitée. La chaîne renvoyée peut être utilisée sans crainte comme partie d’un paramètre à un appel iri_to_uri() sans se préoccuper de double-échappement. Utilise l’exécution différée.
Une version de la fonction Python urllib.quote_plus() pouvant agir sur des chaînes Unicode. L’URL est d’abord codée en UTF-8 avant d’être traitée. La chaîne renvoyée peut être utilisée sans crainte comme partie d’un paramètre à un appel iri_to_uri() sans se préoccuper de double-échappement. Utilise l’exécution différée.
Une version de la fonction Python urllib.urlencode() pouvant agir sur des chaînes Unicode. Les paramètres sont d’abord transformés en chaînes codées en UTF-8, puis codées de manière attendue.
Met en forme la date pour garantir la compatibilité avec le standard de cookie Netscape.
\nAccepte un nombre à virgule exprimé en secondes depuis le temps Unix initial en UTC, de manière semblable à ce que produit time.time(). Si le paramètre est None, c’est la date actuelle qui est renvoyée.
Produit une chaîne au format Wdy, DD-Mon-YYYY HH:MM:SS GMT.
Met en forme la date/heure en respectant le format de date RFC 1123 tel que défini par la RFC 7231 Section 7.1.1.1 du standard HTTP.
\nAccepte un nombre à virgule exprimé en secondes depuis le temps Unix initial en UTC, de manière semblable à ce que produit time.time(). Si le paramètre est None, c’est la date actuelle qui est renvoyée.
Produit une chaîne au format Wdy, DD Mon YYYY HH:MM:SS GMT.
Convertit une chaîne en base 36 en un nombre entier. Avec Python 2, le résultat est toujours de type int, jamais un long.
Convertit un nombre entier positif en une chaîne en base 36. Avec Python 2, i doit être plus petit que sys.maxint.
Code une chaîne d’octets en base64 pour être utilisée dans les URL, en enlevant d’éventuels signes « égal » finaux.
\nDécode une chaîne codée en base64, ajoutant d’éventuels signes « égal » finaux qui pourraient avoir été enlevés.
\ndjango.utils.module_loadingLien vers cette rubrique#Fonctions pour manipuler les modules Python.
\nImporte un chemin pointé de module et renvoie la classe ou l’attribut désigné par le dernier nom du chemin. Génère ImportError si l’importation échoue. Par exemple :
from django.utils.module_loading import import_string\nValidationError = import_string('django.core.exceptions.ValidationError')\nest équivalent à :
\nfrom django.core.exceptions import ValidationError\ndjango.utils.safestringLien vers cette rubrique#Fonctions et classes pour travailler avec des « chaînes sûres » : des chaînes qui peuvent être affichées sans crainte sans devoir subir d’échappement HTML. Quand une chaîne est marquée comme « sûre » (safe), cela signifie que le producteur de la chaîne a déjà transformé en entités appropriées les caractères qui ne doivent pas être interprétés par le moteur HTML (par ex. « < »).
\nUne sous-classe de bytes pour des chaînes ayant été explicitement marquées comme « sûres » (plus besoin d’échappement) à des fins d’affichage HTML.
Une sous-classe de str pour des chaînes ayant été explicitement marquées comme « sûres » (plus besoin d’échappement) à des fins d’affichage HTML. Cela correspond à SafeBytes avec Python 2 et SafeText avec Python 3.
Une sous-classe de str (avec Python 3) ou de unicode (avec Python 2) pour des chaînes ayant été explicitement marquées comme « sûres » (plus besoin d’échappement) à des fins d’affichage HTML.
Nom historique de SafeText. Seulement disponible avec Python 2.
Marque explicitement une chaîne comme sûre en vue de son affichage (HTML). L’objet renvoyé peut être utilisé partout où une chaîne ou un objet unicode peut être utilisé.
\nCette fonction peut être utilisée plusieurs fois sur la même chaîne.
\nPeut aussi être utilisé comme décorateur.
\nPour la construction de fragments de HTML, il est généralement préférable d’utiliser plutôt django.utils.html.format_html().
Une chaîne marquée comme sûre redevient non sûre quand elle est modifiée. Par exemple :
\n>>> mystr = '<b>Hello World</b> '\n>>> mystr = mark_safe(mystr)\n>>> type(mystr)\n<class 'django.utils.safestring.SafeBytes'>\n\n>>> mystr = mystr.strip() # removing whitespace\n>>> type(mystr)\n<type 'str'>\nMarque explicitement une chaîne comme devant être échappée en vue de son affichage HTML. Ceci n’a pas d’effet sur les sous-classes de SafeData.
Cette fonction peut être utilisée plusieurs fois sur la même chaîne (au final, l’échappement n’est appliqué qu’une seule fois).
\ndjango.utils.textLien vers cette rubrique#Une version de str.format() pour les cas où format_string, args ou kwargs contiennent des objets différés. Le premier paramètre est la chaîne à mettre en forme. Par exemple :
from django.utils.text import format_lazy\nfrom django.utils.translation import pgettext_lazy\n\nurlpatterns = [\n url(format_lazy(r'{person}/(?P<pk>\\d+)/$', person=pgettext_lazy('URL', 'person')),\n PersonDetailView.as_view()),\n]\nCet exemple permet aux traducteurs de traduire une partie de l’URL. Si « person » est traduit en « persona », l’expression régulière va correspondre à persona/(?P<pk>\\d+)/$, par ex. persona/5/.
Convertit en ASCII si allow_unicode vaut False (par défaut). Convertit les espaces en tirets. Enlève les caractères qui ne sont ni alphanumériques, ni soulignements, ni tirets. Convertit en minuscules. Les espaces en début et fin de chaîne sont aussi enlevés.
Par exemple :
\nslugify(value)\nSi value contient "Joël est une limace", le résultat sera joel-est-une-limace.
Vous pouvez définir le paramètre allow_unicode à True, si vous souhaitez permettre les caractères Unicode :
slugify(value, allow_unicode=True)\nSi value contient "你好 World", le résultat sera "你好-world".
django.utils.timezoneLien vers cette rubrique#Instance tzinfo qui représente le temps UTC.
Une sous-classe de tzinfo simulant un décalage fixe par rapport au temps UTC. offset est un nombre entier de minutes à l’est d’UTC.
Renvoie une instance tzinfo représentant un fuseau horaire avec un décalage UTC fixe.
offset est une différence de temps datetime.timedelta ou un nombre entier en minutes. Utilisez des valeurs positives pour les fuseaux horaires à l’est d’UTC et des valeurs négatives à l’ouest d’UTC.
Renvoie une instance tzinfo qui représente le fuseau horaire par défaut.
Renvoie le nom du fuseau horaire par défaut.
\nRenvoie une instance tzinfo qui représente le fuseau horaire en cours.
Renvoie le nom du fuseau horaire en cours.
\nDéfinit le fuseau horaire actif. Le paramètre timezone doit être une instance d’une sous-classe de tzinfo ou un nom de fuseau horaire.
Désactive le fuseau horaire actuel.
\nGestionnaire de contexte Python qui définit le fuseau horaire actif lorsqu’il entre en action avec activate(), puis restaure le fuseau horaire précédemment actif en quittant. Si le paramètre timezone vaut None, le fuseau horaire actif est alors désactivé à l’entrée du gestionnaire avec deactivate().
override est aussi utilisable comme décorateur de fonction.
Convertit un objet datetime conscient vers un fuseau horaire différent, par défaut le fuseau horaire actif.
Lorsque value est omise, la valeur par défaut est now().
Cette fonction ne fonctionne pas avec des objets date/heure naïfs ; utilisez alors plutôt make_aware().
Utilise localtime() pour convertir un objet datetime conscient en une date() dans un fuseau horaire différent, par défaut le fuseau horaire actif.
Lorsque value est omise, la valeur par défaut est now().
Cette fonction ne fonctionne pas avec des objets date/heure naïfs.
\nRenvoie un objet datetime représentant le moment actuel dans le temps (« maintenant »). La valeur précisément renvoyée dépend de la valeur de USE_TZ:
Si USE_TZ est False, il s’agira d’une date/heure naïve (c’est-à-dire une date/heure sans fuseau horaire associé) représentant le temps actuel dans le fuseau horaire local du système.
Si USE_TZ est True, il s’agira d’une date/heure consciente représentant le temps actuel en UTC. Notez que now() renvoie toujours le temps UTC quelle que soit la valeur de TIME_ZONE; vous pouvez utiliser localtime() pour convertir vers une date/heure dans le fuseau horaire actif.
Renvoie True si value est consciente, False si elle est naïve. Cette fonction présuppose que value est un objet datetime.
Renvoie True si value est naïve, False si elle est consciente. Cette fonction présuppose que value est un objet datetime.
Renvoie un objet datetime conscient représentant le même moment dans le temps que value dans le fuseau timezone, value étant un objet datetime naïf. Si timezone est défini à None, il prend le fuseau horaire actuel comme valeur par défaut.
L’exception pytz.AmbiguousTimeError est générée quand on essaie de rendre value consciente pendant une transition d’heure d’été/hiver et quand la même heure survient deux fois (passage heure d’été à hiver). En définissant is_dst à True ou False, l’exception est évitée en choisissant si l’heure est celle qui précède ou celle qui suit la transition, respectivement.
L’exception pytz.NonExistentTimeError est générée quand on essaie de rendre value consciente pendant une transition d’heure d’été/hiver et quand l’heure concernée ne survient jamais (passage heure d’hiver à été). En définissant is_dst à True ou False, l’exception est évitée en décalant l’heure de 1 heure en arrière ou en avant, respectivement. Par exemple, is_dst=True change une heure impossible de 2:30 à 1:30 et is_dst=False change la même heure à 3:30.
Renvoie un objet datetime naïf représentant le même moment dans le temps que value dans le fuseau timezone, value étant un objet datetime conscient. Si timezone est défini à None, il prend le fuseau horaire actuel comme valeur par défaut.
django.utils.translationLien vers cette rubrique#Pour une discussion complète sur l’utilisation de ce qui suit, consultez la documentation sur la traduction.
\nTraduit message et renvoie le résultat dans une chaîne d’octets UTF-8
Traduit message et renvoie le résultat dans une chaîne unicode
Traduit message selon context et renvoie le résultat dans une chaîne unicode.
Pour plus d’informations, voir Marqueurs contextuels.
\nMême comportement que les versions non différées ci-dessus, mais en utilisant une exécution différée.
\n\nMarque les chaînes en vue de leur traduction mais ne les traduit pas sur le moment. Cela peut être utile pour stocker des chaînes qui doivent rester dans la langue de base (parce qu’elles pourraient être utilisées de manière externe) dans des variables globales et que ces chaînes seront traduites plus tard.
\nTraduit singular et plural et renvoie la chaîne appropriée en fonction de number dans une chaîne d’octets UTF-8.
Traduit singular et plural et renvoie la chaîne appropriée en fonction de number dans une chaîne unicode.
Traduit singulier et pluriel et renvoie la chaîne appropriée en fonction de nombre et de context dans une chaîne unicode.
Même comportement que les versions non différées ci-dessus, mais en utilisant une exécution différée.
\n\nVariante différée de la concaténation de chaînes, nécessaire pour les traductions qui sont formées de plusieurs parties.
\nRécupère le catalogue de traduction d’une langue donnée et l’active comme catalogue de traduction courant pour le fil d’exécution en cours.
\nDésactive le catalogue de traduction actif afin que des appels à _ subséquents vont refaire appel au catalogue de traduction par défaut.
\nPlace une instance de NullTranslations() comme catalogue de traduction actif. Cela peut être utile si l’on souhaite que des traductions différées apparaissent avec leur chaîne originale (donc non traduite) pour une raison quelconque.
Un gestionnaire de contexte Python qui utilise django.utils.translation.activate() pour récupérer le catalogue de traduction d’une langue données, qui l’active comme catalogue de traduction pour le fil d’exécution en cours et qui réactive la langue précédemment active lors de sa sortie. Il est possible de définir le paramètre deactivate à True si l’on souhaite que la langue de traduction temporaire soit simplement désactivée à la sortie du gestionnaire avec django.utils.translation.deactivate(). Si le paramètre language vaut None, une instance de NullTranslations() est activée dans le code affecté par le gestionnaire de contexte.
override est aussi utilisable comme décorateur de fonction.
Contrôle s’il existe un fichier de langue global pour le code de langue donné (par ex. “fr”, “pt_BR”). Ceci est utilisé pour décider si une langue demandée par un utilisateur est disponible.
\nRenvoie le code de langue actuellement sélectionné. Renvoie None si les traductions sont temporairement désactivées (par deactivate_all() ou lorsque None est passé à override()).
Renvoie l’agencement bidirectionnel de la langue sélectionnée :
\nFalse = agencement de gauche à droite
True = agencement de droite à gauche
Analyse la requête pour trouver quelle est la langue souhaitée par l’utilisateur. Seules les langues figurant dans settings.LANGUAGES sont prises en compte. Si l’utilisateur demande un sous-code de langue alors que seule la langue principale est disponible, c’est la langue principale qui est renvoyée.
Si check_path vaut True, la fonction examine d’abord l’URL demandée pour voir si son chemin commence par un code de langue figurant dans le réglage LANGUAGES.
Transforme un nom de langue (en-us) en un nom de locale (en_US).
\nTransforme un gabarit Django en un contenu analysable par xgettext. Ce processus traduit les balises de traduction de Django en invocations de fonctions gettext standard.
Clé de session servant à stocker la langue active de la session en cours.
\n