This document covers all stable modules in django.utils. Most of the\nmodules in django.utils are designed for internal use and only the\nfollowing parts can be considered stable and thus backwards compatible as per\nthe internal release deprecation policy.
django.utils.cacheLink to this heading#This module contains helper functions for controlling HTTP caching. It does so\nby managing the Vary header of responses. It includes functions to patch\nthe header of response objects directly and decorators that change functions to\ndo that header-patching themselves.
For information on the Vary header, see RFC 7231 Section 7.1.4.
Essentially, the Vary HTTP header defines which headers a cache should take\ninto account when building its cache key. Requests with the same path but\ndifferent header content for headers named in Vary need to get different\ncache keys to prevent delivery of wrong content.
For example, internationalization middleware would\nneed to distinguish caches by the Accept-language header.
This function patches the Cache-Control header by adding all keyword\narguments to it. The transformation is as follows:
All keyword parameter names are turned to lowercase, and underscores\nare converted to hyphens.
If the value of a parameter is True (exactly True, not just a\ntrue value), only the parameter name is added to the header.
All other parameters are added with their value, after applying\nstr() to it.
Returns the max-age from the response Cache-Control header as an integer\n(or None if it wasn't found or wasn't an integer).
Adds some useful headers to the given HttpResponse object:
Expires
Cache-Control
Each header is only added if it isn't already set.
\ncache_timeout is in seconds. The CACHE_MIDDLEWARE_SECONDS\nsetting is used by default.
Adds a Cache-Control: max-age=0, no-cache, no-store, must-revalidate,\nprivate header to a response to indicate that a page should never be\ncached.
Adds (or updates) the Vary header in the given HttpResponse object.\nnewheaders is a list of header names that should be in Vary. If\nheaders contains an asterisk, then Vary header will consist of a single\nasterisk '*'. Otherwise, existing headers in Vary aren't removed.
Mengembalikan sebuah kunci cache pada jalur permintaan. Itu dapat digunakan di tahapan permintaan karena itu mengambil daftar dari kepala untuk diambil kedalam akun dari registrar jalur global dan menggunakan mereka untuk membangun sebuah kunci cache untuk memeriksa.
\nIf there is no headerlist stored, the page needs to be rebuilt, so this\nfunction returns None.
Learns what headers to take into account for some request path from the\nresponse object. It stores those headers in a global path registry so that\nlater access to that path will know what headers to take into account\nwithout building the response object itself. The headers are named in\nthe Vary header of the response, but we want to prevent response\ngeneration.
The list of headers to use for cache key generation is stored in the same\ncache as the pages themselves. If the cache ages some data out of the\ncache, this means that we have to build the response once to get at the\nVary header and so at the list of headers to use for the cache key.
\ndjango.utils.dateparseLink to this heading#The functions defined in this module share the following properties:
\nThey accept strings in ISO 8601 date/time formats (or some close\nalternatives) and return objects from the corresponding classes in Python's\ndatetime module.
They raise ValueError if their input is well formatted but isn't a\nvalid date or time.
They return None if it isn't well formatted at all.
They accept up to picosecond resolution in input, but they truncate it to\nmicroseconds, since that's what Python supports.
Mengurai string dan mengembalikan datetime.date.
Mengurai string dan mengembalikan datetime.time.
UTC offsets aren't supported; if value describes one, the result is\nNone.
Mengurai string dan mengembalikan datetime.datetime.
UTC offsets are supported; if value describes one, the result's\ntzinfo attribute is a datetime.timezone instance.
Mengurai string dan mengembalikan datetime.timedelta.
Expects data in the format "DD HH:MM:SS.uuuuuu",\n"DD HH:MM:SS,uuuuuu", or as specified by ISO 8601 (e.g.\nP4DT1H15M20S which is equivalent to 4 1:15:20) or PostgreSQL's\nday-time interval format (e.g. 3 days 04:05:06).
django.utils.decoratorsLink to this heading#Converts a function decorator into a method decorator. It can be used to\ndecorate methods or classes; in the latter case, name is the name\nof the method to be decorated and is required.
decorator may also be a list or tuple of functions. They are wrapped\nin reverse order so that the call order is the order in which the functions\nappear in the list/tuple.
Lihat decorating class based views untuk contoh penggunaan.
\nGiven a middleware class, returns a view decorator. This lets you use\nmiddleware functionality on a per-view basis. The middleware is created\nwith no params passed.
\nIt assumes middleware that's compatible with the old style of Django 1.9\nand earlier (having methods like process_request(),\nprocess_exception(), and process_response()).
Like decorator_from_middleware, but returns a function\nthat accepts the arguments to be passed to the middleware_class.\nFor example, the cache_page()\ndecorator is created from the CacheMiddleware like this:
cache_page = decorator_from_middleware_with_args(CacheMiddleware)\n\n@cache_page(3600)\ndef my_view(request):\n pass\nMarks a middleware as synchronous-only. (The\ndefault in Django, but this allows you to future-proof if the default ever\nchanges in a future release.)
\nMarks a middleware as asynchronous-only. Django\nwill wrap it in an asynchronous event loop when it is called from the WSGI\nrequest path.
\nMarks a middleware as sync and async compatible,\nthis allows to avoid converting requests. You must implement detection of\nthe current request type to use this decorator. See asynchronous\nmiddleware documentation for details.
\ndjango.utils.encodingLink to this heading#Returns a str object representing arbitrary object s. Treats\nbytestrings using the encoding codec.
If strings_only is True, don't convert (some) non-string-like\nobjects.
Tentukan jika instance obyek adalah jenis dilindungi.
\nObjects of protected types are preserved as-is when passed to\nforce_str(strings_only=True).
Similar to smart_str(), except that lazy instances are resolved to\nstrings, rather than kept as lazy objects.
If strings_only is True, don't convert (some) non-string-like\nobjects.
Returns a bytestring version of arbitrary object s, encoded as\nspecified in encoding.
If strings_only is True, don't convert (some) non-string-like\nobjects.
Similar to smart_bytes, except that lazy instances are resolved to\nbytestrings, rather than kept as lazy objects.
If strings_only is True, don't convert (some) non-string-like\nobjects.
Alias of force_str() for backwards compatibility, especially in code\nthat supports Python 2.
Alias of force_str() for backwards compatibility, especially in code\nthat supports Python 2.
Convert an Internationalized Resource Identifier (IRI) portion to a URI\nportion that is suitable for inclusion in a URL.
\nThis is the algorithm from section 3.1 of RFC 3987 Section 3.1, slightly\nsimplified since the input is assumed to be a string rather than an\narbitrary byte stream.
\nTakes an IRI (string or UTF-8 bytes) and returns a string containing the\nencoded result.
\nMerubah Uniform Resource Identifier menjadi Internationalized Resource Identifier.
\nIni adalah sebuah algoritma dari bagian 3.2 dari RFC 3987 Section 3.2.
\nTakes a URI in ASCII bytes and returns a string containing the encoded\nresult.
\nConvert a file system path to a URI portion that is suitable for inclusion\nin a URL. The path is assumed to be either UTF-8 bytes, string, or a\nPath.
This method will encode certain characters that would normally be\nrecognized as special characters for URIs. Note that this method does not\nencode the ' character, as it is a valid character within URIs. See\nencodeURIComponent() JavaScript function for more details.
Returns an ASCII string containing the encoded result.
\n\nEscapes the unsafe characters from the path portion of a Uniform Resource\nIdentifier (URI).
\ndjango.utils.feedgeneratorLink to this heading#Contoh penggunaan:
\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')\nFor simplifying the selection of a generator use feedgenerator.DefaultFeed\nwhich is currently Rss201rev2Feed
Untuk pengertian dari versi berbeda dari RSS, lihat https://web.archive.org/web/20110718035220/http://diveintomark.org/archives/2004/02/04/incompatible-rss
\nMembuat TagURI.
\nLihat https://web.archive.org/web/20110514113830/http://diveintomark.org/archives/2004/05/28/howto-atom-id
\nEnclosureLink to this heading#Mewakili sebuah lampiran RSS
\nRssFeedLink to this heading#Rss201rev2FeedLink to this heading#Specifikasi: https://cyber.harvard.edu/rss/rss.html
\nRssUserland091FeedLink to this heading#Spesifikasi: http://backend.userland.com/rss091
\nAtom1FeedLink to this heading#Spec: RFC 4287
\ndjango.utils.functionalLink to this heading#The @cached_property decorator caches the result of a method with a\nsingle self argument as a property. The cached result will persist\nas long as the instance does, so if the instance is passed around and the\nfunction subsequently invoked, the cached result will be returned.
Consider a typical case, where a view might need to call a model's method\nto perform some computation, before placing the model instance into the\ncontext, where the template might invoke the method once more:
\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 ...\nDan dalam cetakan anda akan miliki:
\n{% for friend in person.friends %}\nHere, friends() will be called twice. Since the instance person in\nthe view and the template are the same, decorating the friends() method\nwith @cached_property can avoid that:
from django.utils.functional import cached_property\n\nclass Person(models.Model):\n\n @cached_property\n def friends(self):\n ...\nNote that as the method is now a property, in Python code it will need to\nbe accessed appropriately:
\n# in the view:\nif person.friends:\n ...\nThe cached value can be treated like an ordinary attribute of the 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"]\nBecause of the way the descriptor protocol works, using del (or delattr) on a\ncached_property that hasn't been accessed raises AttributeError.
As well as offering potential performance advantages, @cached_property\ncan ensure that an attribute's value does not change unexpectedly over the\nlife of an instance. This could occur with a method whose computation is\nbased on datetime.now(), or if a change were saved to the database by\nsome other process in the brief interval between subsequent invocations of\na method on the same instance.
You can make cached properties of methods. For example, if you had an\nexpensive get_friends() method and wanted to allow calling it without\nretrieving the cached value, you could write:
friends = cached_property(get_friends, name='friends')\nYou only need the name argument for Python < 3.6 support.
While person.get_friends() will recompute the friends on each call, the\nvalue of the cached property will persist until you delete it as described\nabove:
x = person.friends # calls first time\ny = person.get_friends() # calls again\nz = person.friends # does not call\nx is z # is True\nSimilar to @classmethod, the @classproperty\ndecorator converts the result of a method with a single cls argument\ninto a property that can be accessed directly from the class.
Django menawarkan banyak fungsi-fungsi kegunaan (khususnya dalam django.utils) yang mengambil sebuah string sebagai argumen pertama mereka dan melakukan sesuatu ke string itu. Fungsi-fungsi ini digunakan oleh penyaring cetakan sama halnya langsung dalam kode lain.
If you write your own similar functions and deal with translations, you'll\nface the problem of what to do when the first argument is a lazy\ntranslation object. You don't want to convert it to a string immediately,\nbecause you might be using this function outside of a view (and hence the\ncurrent thread's locale setting will not be correct).
\nFor cases like this, use the django.utils.functional.keep_lazy()\ndecorator. It modifies the function so that if it's called with a lazy\ntranslation as one of its arguments, the function evaluation is delayed\nuntil it needs to be converted to a string.
Sebagai contoh:
\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(str)(fancy_utility_function)\n\n# Or more succinctly:\n@keep_lazy(str)\ndef fancy_utility_function(s, ...):\n ...\nThe keep_lazy() decorator takes a number of extra arguments (*args)\nspecifying the type(s) that the original function can return. A common\nuse case is to have functions that return text. For these, you can pass the\nstr type to keep_lazy (or use the keep_lazy_text() decorator\ndescribed in the next section).
Menggunakan penghias ini berarti anda dapat menulis fungsi anda dan menganggap bahwa masukan adalah string yang sesuai, kemudian tambah dukungan untuk obyek terjemahan lazy pada akhirnya.
\nSebuah jalan pintas untuk keep_lazy(str)(func).
If you have a function that returns text and you want to be able to take\nlazy arguments while delaying their evaluation, you can use this\ndecorator:
\nfrom django.utils.functional import keep_lazy, keep_lazy_text\n\n# Our previous example was:\n@keep_lazy(str)\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.htmlLink to this heading#Usually you should build up HTML using Django's templates to make use of its\nautoescape mechanism, using the utilities in django.utils.safestring\nwhere appropriate. This module provides some additional low level utilities for\nescaping HTML.
Returns the given text with ampersands, quotes and angle brackets encoded\nfor use in HTML. The input is first coerced to a string and the output has\nmark_safe() applied.
Mirip pada escape(), kecuali bahwa itu tidak berjalan pada string pra-pelolosan, jadi itu tidak akan pelolosan ganda.
This is similar to str.format(), except that it is appropriate for\nbuilding up HTML fragments. All args and kwargs are passed through\nconditional_escape() before being passed to str.format().
For the case of building up small HTML fragments, this function is to be\npreferred over string interpolation using % or str.format()\ndirectly, because it applies escaping to all arguments - just like the\ntemplate system applies escaping by default.
Jadi, daripada menulis:
\nmark_safe("%s <b>%s</b> %s" % (\n some_html,\n escape(some_text),\n escape(some_other_text),\n))\nSebaiknya anda gunakan:
\nformat_html("{} <b>{}</b> {}",\n mark_safe(some_html),\n some_text,\n some_other_text,\n)\nIni mempunyai keuntungan bahwa anda tidak butuh memberlakukan salinan escape() pada setiap argumen dan resiko sebuah kesalahan dan kerentanan XSS jika anda melupakan satu.
Note that although this function uses str.format() to do the\ninterpolation, some of the formatting options provided by str.format()\n(e.g. number formatting) will not work, since all arguments are passed\nthrough conditional_escape() which (ultimately) calls\nforce_str() on the values.
A wrapper of format_html(), for the common case of a group of\narguments that need to be formatted using the same format string, and then\njoined using sep. sep is also passed through\nconditional_escape().
args_generator should be an iterator that returns the sequence of\nargs that will be passed to format_html(). For example:
format_html_join(\n '\\n', "<li>{} {}</li>",\n ((u.first_name, u.last_name) for u in users)\n)\nMencoba memindahkan apapun yang terlihat seperti etiket HTML dari string, yaitu apapun mengandung dalam <>.
Absolutely NO guarantee is provided about the resulting string being\nHTML safe. So NEVER mark safe the result of a strip_tag call without\nescaping it first, for example with escape().
Sebagai contoh:
\nstrip_tags(value)\nJika value adalah "<b>Joel</b> <button>is</button> a <span>slug</span>" nilai balikan akan menjadi "Joel is a slug".
Jika anda mencari pemecahan yang lebih kuat, lihatlah pustaka Python bleach.
\nMetode __html__() pada kelas membantu cetakan bukan-Django mengenali kelas-kelas yang keluarannya tidak membutuhkan pelolosan HTML.
This decorator defines the __html__() method on the decorated class\nby wrapping __str__() in mark_safe().\nEnsure the __str__() method does indeed return text that doesn't\nrequire HTML escaping.
django.utils.httpLink to this heading#Versi dari fungsi urllib.parse.urlencode() python yang dapat beroperasi pada MultiValueDict dan nilai-nilai bukan-string.
Formats the time to match the RFC 1123 Section 5.2.14 date format as\nspecified by HTTP RFC 7231 Section 7.1.1.1.
\nAccepts a floating point number expressed in seconds since the epoch in\nUTC--such as that outputted by time.time(). If set to None,\ndefaults to the current time.
Outputs a string in the format Wdy, DD Mon YYYY HH:MM:SS GMT.
Converts a base 36 string to an integer.
\nConverts a positive integer to a base 36 string.
\nEncodes a bytestring to a base64 string for use in URLs, stripping any\ntrailing equal signs.
\nDecodes a base64 encoded string, adding back any trailing equal signs that\nmight have been stripped.
\ndjango.utils.module_loadingLink to this heading#Fungsi-fungsi untuk bekerja dengan modeul-modul Python.
\nImports a dotted module path and returns the attribute/class designated by\nthe last name in the path. Raises ImportError if the import failed. For\nexample:
from django.utils.module_loading import import_string\nValidationError = import_string('django.core.exceptions.ValidationError')\nsetara pada:
\nfrom django.core.exceptions import ValidationError\ndjango.utils.safestringLink to this heading#Functions and classes for working with "safe strings": strings that can be\ndisplayed safely without further escaping in HTML. Marking something as a "safe\nstring" means that the producer of the string has already turned characters\nthat should not be interpreted by the HTML engine (e.g. '<') into the\nappropriate entities.
\nA str subclass that has been specifically marked as "safe" (requires no\nfurther escaping) for HTML output purposes.
Explicitly mark a string as safe for (HTML) output purposes. The returned\nobject can be used everywhere a string is appropriate.
\nCan be called multiple times on a single string.
\nCan also be used as a decorator.
\nFor building up fragments of HTML, you should normally be using\ndjango.utils.html.format_html() instead.
String marked safe will become unsafe again if modified. For example:
\n>>> mystr = '<b>Hello World</b> '\n>>> mystr = mark_safe(mystr)\n>>> type(mystr)\n<class 'django.utils.safestring.SafeString'>\n\n>>> mystr = mystr.strip() # removing whitespace\n>>> type(mystr)\n<type 'str'>\ndjango.utils.textLink to this heading#A version of str.format() for when format_string, args,\nand/or kwargs contain lazy objects. The first argument is the string to\nbe formatted. For example:
from django.utils.text import format_lazy\nfrom django.utils.translation import pgettext_lazy\n\nurlpatterns = [\n path(format_lazy('{person}/<int:pk>/', person=pgettext_lazy('URL', 'person')),\n PersonDetailView.as_view()),\n]\nThis example allows translators to translate part of the URL. If "person"\nis translated to "persona", the regular expression will match\npersona/(?P<pk>\\d+)/$, e.g. persona/5/.
Merubah string menjadi sebuah tanda siput URL dengan:
\nConverting to ASCII if allow_unicode is False (the default).
Merubah ke huruf kecil.
Removing characters that aren't alphanumerics, underscores, hyphens, or\nwhitespace.
Removing leading and trailing whitespace.
Replacing any whitespace or repeated dashes with single dashes.
Sebagai contoh:
\n>>> slugify(' Joel is a slug ')\n'joel-is-a-slug'\nIf you want to allow Unicode characters, pass allow_unicode=True. For\nexample:
>>> slugify('你好 World', allow_unicode=True)\n'你好-world'\ndjango.utils.timezoneLink to this heading#tzinfo instance that represents UTC.
Returns a tzinfo instance that represents a time zone\nwith a fixed offset from UTC.
offset is a datetime.timedelta or an integer number of\nminutes. Use positive values for time zones east of UTC and negative\nvalues for west of UTC.
Returns a tzinfo instance that represents the\ndefault time zone.
Returns the name of the default time zone.
\nReturns a tzinfo instance that represents the\ncurrent time zone.
Returns the name of the current time zone.
\nSets the current time zone. The\ntimezone argument must be an instance of a tzinfo\nsubclass or a time zone name.
Tidak disetel current time zone.
\nThis is a Python context manager that sets the current time zone on entry with activate(), and restores\nthe previously active time zone on exit. If the timezone argument is\nNone, the current time zone is unset\non entry with deactivate() instead.
override is also usable as a function decorator.
Converts an aware datetime to a different time zone,\nby default the current time zone.
Ketika value dihilangkan, itu awalan pada now().
Fungsi ini tidak bekerja pada datetime yang tidak dibuat-buat., gunakan make_aware() sebagai gantinya.
Uses localtime() to convert an aware datetime to a\ndate() in a different time zone, by default the\ncurrent time zone.
Ketika value dihilangkan, itu awalan pada now().
Fungsi ini tidak bekerja pada datetime yang tidak dibuat-buat.
\nReturns a datetime that represents the\ncurrent point in time. Exactly what's returned depends on the value of\nUSE_TZ:
If USE_TZ is False, this will be a\nnaive datetime (i.e. a datetime\nwithout an associated timezone) that represents the current time\nin the system's local timezone.
If USE_TZ is True, this will be an\naware datetime representing the\ncurrent time in UTC. Note that now() will always return\ntimes in UTC regardless of the value of TIME_ZONE;\nyou can use localtime() to get the time in the current time zone.
Returns True if value is aware, False if it is naive. This\nfunction assumes that value is a datetime.
Returns True if value is naive, False if it is aware. This\nfunction assumes that value is a datetime.
Returns an aware datetime that represents the same\npoint in time as value in timezone, value being a naive\ndatetime. If timezone is set to None, it\ndefaults to the current time zone.
The pytz.AmbiguousTimeError exception is raised if you try to make\nvalue aware during a DST transition where the same time occurs twice\n(when reverting from DST). Setting is_dst to True or False will\navoid the exception by choosing if the time is pre-transition or\npost-transition respectively.
The pytz.NonExistentTimeError exception is raised if you try to make\nvalue aware during a DST transition such that the time never occurred.\nFor example, if the 2:00 hour is skipped during a DST transition, trying to\nmake 2:30 aware in that time zone will raise an exception. To avoid that\nyou can use is_dst to specify how make_aware() should interpret\nsuch a nonexistent time. If is_dst=True then the above time would be\ninterpreted as 2:30 DST time (equivalent to 1:30 local time). Conversely,\nif is_dst=False the time would be interpreted as 2:30 standard time\n(equivalent to 3:30 local time).
Returns a naive datetime that represents in\ntimezone the same point in time as value, value being an\naware datetime. If timezone is set to None, it\ndefaults to the current time zone.
django.utils.translationLink to this heading#Untuk obrolan lengkap pada penggunakan dari berikut lihat translation documentation.
\nMenterjemahkan message dan mengembalikan itu sebagai sebuah string.
Menterjemahkan message memberikan contect dan mengembalikan itu sebagai sebuah string.
Untuk informasi lebih, lihat Contextual markers.
\nSame as the non-lazy versions above, but using lazy execution.
\n\nMarks strings for translation but doesn't translate them now. This can be\nused to store strings in global variables that should stay in the base\nlanguage (because they might be used externally) and will be translated\nlater.
\nTranslates singular and plural and returns the appropriate string\nbased on number.
Translates singular and plural and returns the appropriate string\nbased on number and the context.
Same as the non-lazy versions above, but using lazy execution.
\n\nFetches the translation object for a given language and activates it as\nthe current translation object for the current thread.
\nDeactivates the currently active translation object so that further _ calls\nwill resolve against the default translation object, again.
\nMakes the active translation object a NullTranslations() instance.\nThis is useful when we want delayed translations to appear as the original\nstring for some reason.
A Python context manager that uses\ndjango.utils.translation.activate() to fetch the translation object\nfor a given language, activates it as the translation object for the\ncurrent thread and reactivates the previous active language on exit.\nOptionally, it can deactivate the temporary translation on exit with\ndjango.utils.translation.deactivate() if the deactivate argument\nis True. If you pass None as the language argument, a\nNullTranslations() instance is activated within the context.
override is also usable as a function decorator.
Checks whether there is a global language file for the given language\ncode (e.g. 'fr', 'pt_BR'). This is used to decide whether a user-provided\nlanguage is available.
\nReturns the currently selected language code. Returns None if\ntranslations are temporarily deactivated (by deactivate_all() or\nwhen None is passed to override()).
Returns selected language's BiDi layout:
\nFalse = tata letak kiri-ke-kanan
True = tata letak kanan-ke-kiri
Analyzes the request to find what language the user wants the system to\nshow. Only languages listed in settings.LANGUAGES are taken into account.\nIf the user requests a sublanguage where we have a main language, we send\nout the main language.
\nIf check_path is True, the function first checks the requested URL\nfor whether its path begins with a language code listed in the\nLANGUAGES setting.
Returns lang_code if it's in the LANGUAGES setting, possibly\nselecting a more generic variant. For example, 'es' is returned if\nlang_code is 'es-ar' and 'es' is in LANGUAGES but\n'es-ar' isn't.
If strict is False (the default), a country-specific variant may\nbe returned when neither the language code nor its generic variant is found.\nFor example, if only 'es-co' is in LANGUAGES, that's\nreturned for lang_codes like 'es' and 'es-ar'. Those matches\naren't returned if strict=True.
Memunculkan LookupError jika tidak ditemukan apapun.
Mengubah nama basaha (en-us) menjadi nama lokal (en_US).
\nTurns a Django template into something that is understood by xgettext.\nIt does so by translating the Django translation tags into standard\ngettext function invocations.
Session key under which the active language for the current session is\nstored.
\n\n