before send to remote

env/lib/python3.8/site-packages/django/contrib/postgres/aggregates/__init__.py

@@ -0,0 +1,2 @@
+from .general import *  # NOQA
+from .statistics import *  # NOQA

env/lib/python3.8/site-packages/django/contrib/postgres/aggregates/general.py

@@ -0,0 +1,115 @@
+import warnings
+
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Aggregate, BooleanField, JSONField, TextField, Value
+from django.utils.deprecation import RemovedInDjango50Warning
+
+from .mixins import OrderableAggMixin
+
+__all__ = [
+    "ArrayAgg",
+    "BitAnd",
+    "BitOr",
+    "BitXor",
+    "BoolAnd",
+    "BoolOr",
+    "JSONBAgg",
+    "StringAgg",
+]
+
+
+# RemovedInDjango50Warning
+NOT_PROVIDED = object()
+
+
+class DeprecatedConvertValueMixin:
+    def __init__(self, *expressions, default=NOT_PROVIDED, **extra):
+        if default is NOT_PROVIDED:
+            default = None
+            self._default_provided = False
+        else:
+            self._default_provided = True
+        super().__init__(*expressions, default=default, **extra)
+
+    def convert_value(self, value, expression, connection):
+        if value is None and not self._default_provided:
+            warnings.warn(self.deprecation_msg, category=RemovedInDjango50Warning)
+            return self.deprecation_value
+        return value
+
+
+class ArrayAgg(DeprecatedConvertValueMixin, OrderableAggMixin, Aggregate):
+    function = "ARRAY_AGG"
+    template = "%(function)s(%(distinct)s%(expressions)s %(ordering)s)"
+    allow_distinct = True
+
+    # RemovedInDjango50Warning
+    deprecation_value = property(lambda self: [])
+    deprecation_msg = (
+        "In Django 5.0, ArrayAgg() will return None instead of an empty list "
+        "if there are no rows. Pass default=None to opt into the new behavior "
+        "and silence this warning or default=Value([]) to keep the previous "
+        "behavior."
+    )
+
+    @property
+    def output_field(self):
+        return ArrayField(self.source_expressions[0].output_field)
+
+
+class BitAnd(Aggregate):
+    function = "BIT_AND"
+
+
+class BitOr(Aggregate):
+    function = "BIT_OR"
+
+
+class BitXor(Aggregate):
+    function = "BIT_XOR"
+
+
+class BoolAnd(Aggregate):
+    function = "BOOL_AND"
+    output_field = BooleanField()
+
+
+class BoolOr(Aggregate):
+    function = "BOOL_OR"
+    output_field = BooleanField()
+
+
+class JSONBAgg(DeprecatedConvertValueMixin, OrderableAggMixin, Aggregate):
+    function = "JSONB_AGG"
+    template = "%(function)s(%(distinct)s%(expressions)s %(ordering)s)"
+    allow_distinct = True
+    output_field = JSONField()
+
+    # RemovedInDjango50Warning
+    deprecation_value = "[]"
+    deprecation_msg = (
+        "In Django 5.0, JSONBAgg() will return None instead of an empty list "
+        "if there are no rows. Pass default=None to opt into the new behavior "
+        "and silence this warning or default=Value('[]') to keep the previous "
+        "behavior."
+    )
+
+
+class StringAgg(DeprecatedConvertValueMixin, OrderableAggMixin, Aggregate):
+    function = "STRING_AGG"
+    template = "%(function)s(%(distinct)s%(expressions)s %(ordering)s)"
+    allow_distinct = True
+    output_field = TextField()
+
+    # RemovedInDjango50Warning
+    deprecation_value = ""
+    deprecation_msg = (
+        "In Django 5.0, StringAgg() will return None instead of an empty "
+        "string if there are no rows. Pass default=None to opt into the new "
+        "behavior and silence this warning or default=Value('') to keep the "
+        "previous behavior."
+    )
+
+    def __init__(self, expression, delimiter, **extra):
+        delimiter_expr = Value(str(delimiter))
+        super().__init__(expression, delimiter_expr, **extra)

env/lib/python3.8/site-packages/django/contrib/postgres/aggregates/mixins.py

@@ -0,0 +1,26 @@
+from django.db.models.expressions import OrderByList
+
+
+class OrderableAggMixin:
+    def __init__(self, *expressions, ordering=(), **extra):
+        if isinstance(ordering, (list, tuple)):
+            self.order_by = OrderByList(*ordering)
+        else:
+            self.order_by = OrderByList(ordering)
+        super().__init__(*expressions, **extra)
+
+    def resolve_expression(self, *args, **kwargs):
+        self.order_by = self.order_by.resolve_expression(*args, **kwargs)
+        return super().resolve_expression(*args, **kwargs)
+
+    def get_source_expressions(self):
+        return super().get_source_expressions() + [self.order_by]
+
+    def set_source_expressions(self, exprs):
+        *exprs, self.order_by = exprs
+        return super().set_source_expressions(exprs)
+
+    def as_sql(self, compiler, connection):
+        order_by_sql, order_by_params = compiler.compile(self.order_by)
+        sql, sql_params = super().as_sql(compiler, connection, ordering=order_by_sql)
+        return sql, (*sql_params, *order_by_params)

env/lib/python3.8/site-packages/django/contrib/postgres/aggregates/statistics.py

@@ -0,0 +1,75 @@
+from django.db.models import Aggregate, FloatField, IntegerField
+
+__all__ = [
+    "CovarPop",
+    "Corr",
+    "RegrAvgX",
+    "RegrAvgY",
+    "RegrCount",
+    "RegrIntercept",
+    "RegrR2",
+    "RegrSlope",
+    "RegrSXX",
+    "RegrSXY",
+    "RegrSYY",
+    "StatAggregate",
+]
+
+
+class StatAggregate(Aggregate):
+    output_field = FloatField()
+
+    def __init__(self, y, x, output_field=None, filter=None, default=None):
+        if not x or not y:
+            raise ValueError("Both y and x must be provided.")
+        super().__init__(
+            y, x, output_field=output_field, filter=filter, default=default
+        )
+
+
+class Corr(StatAggregate):
+    function = "CORR"
+
+
+class CovarPop(StatAggregate):
+    def __init__(self, y, x, sample=False, filter=None, default=None):
+        self.function = "COVAR_SAMP" if sample else "COVAR_POP"
+        super().__init__(y, x, filter=filter, default=default)
+
+
+class RegrAvgX(StatAggregate):
+    function = "REGR_AVGX"
+
+
+class RegrAvgY(StatAggregate):
+    function = "REGR_AVGY"
+
+
+class RegrCount(StatAggregate):
+    function = "REGR_COUNT"
+    output_field = IntegerField()
+    empty_result_set_value = 0
+
+
+class RegrIntercept(StatAggregate):
+    function = "REGR_INTERCEPT"
+
+
+class RegrR2(StatAggregate):
+    function = "REGR_R2"
+
+
+class RegrSlope(StatAggregate):
+    function = "REGR_SLOPE"
+
+
+class RegrSXX(StatAggregate):
+    function = "REGR_SXX"
+
+
+class RegrSXY(StatAggregate):
+    function = "REGR_SXY"
+
+
+class RegrSYY(StatAggregate):
+    function = "REGR_SYY"

env/lib/python3.8/site-packages/django/contrib/postgres/apps.py

@@ -0,0 +1,77 @@
+from psycopg2.extras import DateRange, DateTimeRange, DateTimeTZRange, NumericRange
+
+from django.apps import AppConfig
+from django.core.signals import setting_changed
+from django.db import connections
+from django.db.backends.signals import connection_created
+from django.db.migrations.writer import MigrationWriter
+from django.db.models import CharField, OrderBy, TextField
+from django.db.models.functions import Collate
+from django.db.models.indexes import IndexExpression
+from django.utils.translation import gettext_lazy as _
+
+from .indexes import OpClass
+from .lookups import SearchLookup, TrigramSimilar, TrigramWordSimilar, Unaccent
+from .serializers import RangeSerializer
+from .signals import register_type_handlers
+
+RANGE_TYPES = (DateRange, DateTimeRange, DateTimeTZRange, NumericRange)
+
+
+def uninstall_if_needed(setting, value, enter, **kwargs):
+    """
+    Undo the effects of PostgresConfig.ready() when django.contrib.postgres
+    is "uninstalled" by override_settings().
+    """
+    if (
+        not enter
+        and setting == "INSTALLED_APPS"
+        and "django.contrib.postgres" not in set(value)
+    ):
+        connection_created.disconnect(register_type_handlers)
+        CharField._unregister_lookup(Unaccent)
+        TextField._unregister_lookup(Unaccent)
+        CharField._unregister_lookup(SearchLookup)
+        TextField._unregister_lookup(SearchLookup)
+        CharField._unregister_lookup(TrigramSimilar)
+        TextField._unregister_lookup(TrigramSimilar)
+        CharField._unregister_lookup(TrigramWordSimilar)
+        TextField._unregister_lookup(TrigramWordSimilar)
+        # Disconnect this receiver until the next time this app is installed
+        # and ready() connects it again to prevent unnecessary processing on
+        # each setting change.
+        setting_changed.disconnect(uninstall_if_needed)
+        MigrationWriter.unregister_serializer(RANGE_TYPES)
+
+
+class PostgresConfig(AppConfig):
+    name = "django.contrib.postgres"
+    verbose_name = _("PostgreSQL extensions")
+
+    def ready(self):
+        setting_changed.connect(uninstall_if_needed)
+        # Connections may already exist before we are called.
+        for conn in connections.all(initialized_only=True):
+            if conn.vendor == "postgresql":
+                conn.introspection.data_types_reverse.update(
+                    {
+                        3904: "django.contrib.postgres.fields.IntegerRangeField",
+                        3906: "django.contrib.postgres.fields.DecimalRangeField",
+                        3910: "django.contrib.postgres.fields.DateTimeRangeField",
+                        3912: "django.contrib.postgres.fields.DateRangeField",
+                        3926: "django.contrib.postgres.fields.BigIntegerRangeField",
+                    }
+                )
+                if conn.connection is not None:
+                    register_type_handlers(conn)
+        connection_created.connect(register_type_handlers)
+        CharField.register_lookup(Unaccent)
+        TextField.register_lookup(Unaccent)
+        CharField.register_lookup(SearchLookup)
+        TextField.register_lookup(SearchLookup)
+        CharField.register_lookup(TrigramSimilar)
+        TextField.register_lookup(TrigramSimilar)
+        CharField.register_lookup(TrigramWordSimilar)
+        TextField.register_lookup(TrigramWordSimilar)
+        MigrationWriter.register_serializer(RANGE_TYPES, RangeSerializer)
+        IndexExpression.register_wrappers(OrderBy, OpClass, Collate)

env/lib/python3.8/site-packages/django/contrib/postgres/constraints.py

@@ -0,0 +1,244 @@
+import warnings
+
+from django.contrib.postgres.indexes import OpClass
+from django.core.exceptions import ValidationError
+from django.db import DEFAULT_DB_ALIAS, NotSupportedError
+from django.db.backends.ddl_references import Expressions, Statement, Table
+from django.db.models import BaseConstraint, Deferrable, F, Q
+from django.db.models.expressions import Exists, ExpressionList
+from django.db.models.indexes import IndexExpression
+from django.db.models.lookups import PostgresOperatorLookup
+from django.db.models.sql import Query
+from django.utils.deprecation import RemovedInDjango50Warning
+
+__all__ = ["ExclusionConstraint"]
+
+
+class ExclusionConstraintExpression(IndexExpression):
+    template = "%(expressions)s WITH %(operator)s"
+
+
+class ExclusionConstraint(BaseConstraint):
+    template = (
+        "CONSTRAINT %(name)s EXCLUDE USING %(index_type)s "
+        "(%(expressions)s)%(include)s%(where)s%(deferrable)s"
+    )
+
+    def __init__(
+        self,
+        *,
+        name,
+        expressions,
+        index_type=None,
+        condition=None,
+        deferrable=None,
+        include=None,
+        opclasses=(),
+        violation_error_message=None,
+    ):
+        if index_type and index_type.lower() not in {"gist", "spgist"}:
+            raise ValueError(
+                "Exclusion constraints only support GiST or SP-GiST indexes."
+            )
+        if not expressions:
+            raise ValueError(
+                "At least one expression is required to define an exclusion "
+                "constraint."
+            )
+        if not all(
+            isinstance(expr, (list, tuple)) and len(expr) == 2 for expr in expressions
+        ):
+            raise ValueError("The expressions must be a list of 2-tuples.")
+        if not isinstance(condition, (type(None), Q)):
+            raise ValueError("ExclusionConstraint.condition must be a Q instance.")
+        if condition and deferrable:
+            raise ValueError("ExclusionConstraint with conditions cannot be deferred.")
+        if not isinstance(deferrable, (type(None), Deferrable)):
+            raise ValueError(
+                "ExclusionConstraint.deferrable must be a Deferrable instance."
+            )
+        if not isinstance(include, (type(None), list, tuple)):
+            raise ValueError("ExclusionConstraint.include must be a list or tuple.")
+        if not isinstance(opclasses, (list, tuple)):
+            raise ValueError("ExclusionConstraint.opclasses must be a list or tuple.")
+        if opclasses and len(expressions) != len(opclasses):
+            raise ValueError(
+                "ExclusionConstraint.expressions and "
+                "ExclusionConstraint.opclasses must have the same number of "
+                "elements."
+            )
+        self.expressions = expressions
+        self.index_type = index_type or "GIST"
+        self.condition = condition
+        self.deferrable = deferrable
+        self.include = tuple(include) if include else ()
+        self.opclasses = opclasses
+        if self.opclasses:
+            warnings.warn(
+                "The opclasses argument is deprecated in favor of using "
+                "django.contrib.postgres.indexes.OpClass in "
+                "ExclusionConstraint.expressions.",
+                category=RemovedInDjango50Warning,
+                stacklevel=2,
+            )
+        super().__init__(name=name, violation_error_message=violation_error_message)
+
+    def _get_expressions(self, schema_editor, query):
+        expressions = []
+        for idx, (expression, operator) in enumerate(self.expressions):
+            if isinstance(expression, str):
+                expression = F(expression)
+            try:
+                expression = OpClass(expression, self.opclasses[idx])
+            except IndexError:
+                pass
+            expression = ExclusionConstraintExpression(expression, operator=operator)
+            expression.set_wrapper_classes(schema_editor.connection)
+            expressions.append(expression)
+        return ExpressionList(*expressions).resolve_expression(query)
+
+    def _get_condition_sql(self, compiler, schema_editor, query):
+        if self.condition is None:
+            return None
+        where = query.build_where(self.condition)
+        sql, params = where.as_sql(compiler, schema_editor.connection)
+        return sql % tuple(schema_editor.quote_value(p) for p in params)
+
+    def constraint_sql(self, model, schema_editor):
+        query = Query(model, alias_cols=False)
+        compiler = query.get_compiler(connection=schema_editor.connection)
+        expressions = self._get_expressions(schema_editor, query)
+        table = model._meta.db_table
+        condition = self._get_condition_sql(compiler, schema_editor, query)
+        include = [
+            model._meta.get_field(field_name).column for field_name in self.include
+        ]
+        return Statement(
+            self.template,
+            table=Table(table, schema_editor.quote_name),
+            name=schema_editor.quote_name(self.name),
+            index_type=self.index_type,
+            expressions=Expressions(
+                table, expressions, compiler, schema_editor.quote_value
+            ),
+            where=" WHERE (%s)" % condition if condition else "",
+            include=schema_editor._index_include_sql(model, include),
+            deferrable=schema_editor._deferrable_constraint_sql(self.deferrable),
+        )
+
+    def create_sql(self, model, schema_editor):
+        self.check_supported(schema_editor)
+        return Statement(
+            "ALTER TABLE %(table)s ADD %(constraint)s",
+            table=Table(model._meta.db_table, schema_editor.quote_name),
+            constraint=self.constraint_sql(model, schema_editor),
+        )
+
+    def remove_sql(self, model, schema_editor):
+        return schema_editor._delete_constraint_sql(
+            schema_editor.sql_delete_check,
+            model,
+            schema_editor.quote_name(self.name),
+        )
+
+    def check_supported(self, schema_editor):
+        if (
+            self.include
+            and self.index_type.lower() == "gist"
+            and not schema_editor.connection.features.supports_covering_gist_indexes
+        ):
+            raise NotSupportedError(
+                "Covering exclusion constraints using a GiST index require "
+                "PostgreSQL 12+."
+            )
+        if (
+            self.include
+            and self.index_type.lower() == "spgist"
+            and not schema_editor.connection.features.supports_covering_spgist_indexes
+        ):
+            raise NotSupportedError(
+                "Covering exclusion constraints using an SP-GiST index "
+                "require PostgreSQL 14+."
+            )
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        kwargs["expressions"] = self.expressions
+        if self.condition is not None:
+            kwargs["condition"] = self.condition
+        if self.index_type.lower() != "gist":
+            kwargs["index_type"] = self.index_type
+        if self.deferrable:
+            kwargs["deferrable"] = self.deferrable
+        if self.include:
+            kwargs["include"] = self.include
+        if self.opclasses:
+            kwargs["opclasses"] = self.opclasses
+        return path, args, kwargs
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return (
+                self.name == other.name
+                and self.index_type == other.index_type
+                and self.expressions == other.expressions
+                and self.condition == other.condition
+                and self.deferrable == other.deferrable
+                and self.include == other.include
+                and self.opclasses == other.opclasses
+                and self.violation_error_message == other.violation_error_message
+            )
+        return super().__eq__(other)
+
+    def __repr__(self):
+        return "<%s: index_type=%s expressions=%s name=%s%s%s%s%s>" % (
+            self.__class__.__qualname__,
+            repr(self.index_type),
+            repr(self.expressions),
+            repr(self.name),
+            "" if self.condition is None else " condition=%s" % self.condition,
+            "" if self.deferrable is None else " deferrable=%r" % self.deferrable,
+            "" if not self.include else " include=%s" % repr(self.include),
+            "" if not self.opclasses else " opclasses=%s" % repr(self.opclasses),
+        )
+
+    def validate(self, model, instance, exclude=None, using=DEFAULT_DB_ALIAS):
+        queryset = model._default_manager.using(using)
+        replacement_map = instance._get_field_value_map(
+            meta=model._meta, exclude=exclude
+        )
+        lookups = []
+        for idx, (expression, operator) in enumerate(self.expressions):
+            if isinstance(expression, str):
+                expression = F(expression)
+            if isinstance(expression, F):
+                if exclude and expression.name in exclude:
+                    return
+                rhs_expression = replacement_map.get(expression.name, expression)
+            else:
+                rhs_expression = expression.replace_references(replacement_map)
+                if exclude:
+                    for expr in rhs_expression.flatten():
+                        if isinstance(expr, F) and expr.name in exclude:
+                            return
+            # Remove OpClass because it only has sense during the constraint
+            # creation.
+            if isinstance(expression, OpClass):
+                expression = expression.get_source_expressions()[0]
+            if isinstance(rhs_expression, OpClass):
+                rhs_expression = rhs_expression.get_source_expressions()[0]
+            lookup = PostgresOperatorLookup(lhs=expression, rhs=rhs_expression)
+            lookup.postgres_operator = operator
+            lookups.append(lookup)
+        queryset = queryset.filter(*lookups)
+        model_class_pk = instance._get_pk_val(model._meta)
+        if not instance._state.adding and model_class_pk is not None:
+            queryset = queryset.exclude(pk=model_class_pk)
+        if not self.condition:
+            if queryset.exists():
+                raise ValidationError(self.get_violation_error_message())
+        else:
+            if (self.condition & Exists(queryset.filter(self.condition))).check(
+                replacement_map, using=using
+            ):
+                raise ValidationError(self.get_violation_error_message())

env/lib/python3.8/site-packages/django/contrib/postgres/expressions.py

@@ -0,0 +1,14 @@
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Subquery
+from django.utils.functional import cached_property
+
+
+class ArraySubquery(Subquery):
+    template = "ARRAY(%(subquery)s)"
+
+    def __init__(self, queryset, **kwargs):
+        super().__init__(queryset, **kwargs)
+
+    @cached_property
+    def output_field(self):
+        return ArrayField(self.query.output_field)

env/lib/python3.8/site-packages/django/contrib/postgres/fields/__init__.py

@@ -0,0 +1,5 @@
+from .array import *  # NOQA
+from .citext import *  # NOQA
+from .hstore import *  # NOQA
+from .jsonb import *  # NOQA
+from .ranges import *  # NOQA

env/lib/python3.8/site-packages/django/contrib/postgres/fields/array.py

@@ -0,0 +1,329 @@
+import json
+
+from django.contrib.postgres import lookups
+from django.contrib.postgres.forms import SimpleArrayField
+from django.contrib.postgres.validators import ArrayMaxLengthValidator
+from django.core import checks, exceptions
+from django.db.models import Field, Func, IntegerField, Transform, Value
+from django.db.models.fields.mixins import CheckFieldDefaultMixin
+from django.db.models.lookups import Exact, In
+from django.utils.translation import gettext_lazy as _
+
+from ..utils import prefix_validation_error
+from .utils import AttributeSetter
+
+__all__ = ["ArrayField"]
+
+
+class ArrayField(CheckFieldDefaultMixin, Field):
+    empty_strings_allowed = False
+    default_error_messages = {
+        "item_invalid": _("Item %(nth)s in the array did not validate:"),
+        "nested_array_mismatch": _("Nested arrays must have the same length."),
+    }
+    _default_hint = ("list", "[]")
+
+    def __init__(self, base_field, size=None, **kwargs):
+        self.base_field = base_field
+        self.size = size
+        if self.size:
+            self.default_validators = [
+                *self.default_validators,
+                ArrayMaxLengthValidator(self.size),
+            ]
+        # For performance, only add a from_db_value() method if the base field
+        # implements it.
+        if hasattr(self.base_field, "from_db_value"):
+            self.from_db_value = self._from_db_value
+        super().__init__(**kwargs)
+
+    @property
+    def model(self):
+        try:
+            return self.__dict__["model"]
+        except KeyError:
+            raise AttributeError(
+                "'%s' object has no attribute 'model'" % self.__class__.__name__
+            )
+
+    @model.setter
+    def model(self, model):
+        self.__dict__["model"] = model
+        self.base_field.model = model
+
+    @classmethod
+    def _choices_is_value(cls, value):
+        return isinstance(value, (list, tuple)) or super()._choices_is_value(value)
+
+    def check(self, **kwargs):
+        errors = super().check(**kwargs)
+        if self.base_field.remote_field:
+            errors.append(
+                checks.Error(
+                    "Base field for array cannot be a related field.",
+                    obj=self,
+                    id="postgres.E002",
+                )
+            )
+        else:
+            # Remove the field name checks as they are not needed here.
+            base_errors = self.base_field.check()
+            if base_errors:
+                messages = "\n    ".join(
+                    "%s (%s)" % (error.msg, error.id) for error in base_errors
+                )
+                errors.append(
+                    checks.Error(
+                        "Base field for array has errors:\n    %s" % messages,
+                        obj=self,
+                        id="postgres.E001",
+                    )
+                )
+        return errors
+
+    def set_attributes_from_name(self, name):
+        super().set_attributes_from_name(name)
+        self.base_field.set_attributes_from_name(name)
+
+    @property
+    def description(self):
+        return "Array of %s" % self.base_field.description
+
+    def db_type(self, connection):
+        size = self.size or ""
+        return "%s[%s]" % (self.base_field.db_type(connection), size)
+
+    def cast_db_type(self, connection):
+        size = self.size or ""
+        return "%s[%s]" % (self.base_field.cast_db_type(connection), size)
+
+    def get_placeholder(self, value, compiler, connection):
+        return "%s::{}".format(self.db_type(connection))
+
+    def get_db_prep_value(self, value, connection, prepared=False):
+        if isinstance(value, (list, tuple)):
+            return [
+                self.base_field.get_db_prep_value(i, connection, prepared=False)
+                for i in value
+            ]
+        return value
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if path == "django.contrib.postgres.fields.array.ArrayField":
+            path = "django.contrib.postgres.fields.ArrayField"
+        kwargs.update(
+            {
+                "base_field": self.base_field.clone(),
+                "size": self.size,
+            }
+        )
+        return name, path, args, kwargs
+
+    def to_python(self, value):
+        if isinstance(value, str):
+            # Assume we're deserializing
+            vals = json.loads(value)
+            value = [self.base_field.to_python(val) for val in vals]
+        return value
+
+    def _from_db_value(self, value, expression, connection):
+        if value is None:
+            return value
+        return [
+            self.base_field.from_db_value(item, expression, connection)
+            for item in value
+        ]
+
+    def value_to_string(self, obj):
+        values = []
+        vals = self.value_from_object(obj)
+        base_field = self.base_field
+
+        for val in vals:
+            if val is None:
+                values.append(None)
+            else:
+                obj = AttributeSetter(base_field.attname, val)
+                values.append(base_field.value_to_string(obj))
+        return json.dumps(values)
+
+    def get_transform(self, name):
+        transform = super().get_transform(name)
+        if transform:
+            return transform
+        if "_" not in name:
+            try:
+                index = int(name)
+            except ValueError:
+                pass
+            else:
+                index += 1  # postgres uses 1-indexing
+                return IndexTransformFactory(index, self.base_field)
+        try:
+            start, end = name.split("_")
+            start = int(start) + 1
+            end = int(end)  # don't add one here because postgres slices are weird
+        except ValueError:
+            pass
+        else:
+            return SliceTransformFactory(start, end)
+
+    def validate(self, value, model_instance):
+        super().validate(value, model_instance)
+        for index, part in enumerate(value):
+            try:
+                self.base_field.validate(part, model_instance)
+            except exceptions.ValidationError as error:
+                raise prefix_validation_error(
+                    error,
+                    prefix=self.error_messages["item_invalid"],
+                    code="item_invalid",
+                    params={"nth": index + 1},
+                )
+        if isinstance(self.base_field, ArrayField):
+            if len({len(i) for i in value}) > 1:
+                raise exceptions.ValidationError(
+                    self.error_messages["nested_array_mismatch"],
+                    code="nested_array_mismatch",
+                )
+
+    def run_validators(self, value):
+        super().run_validators(value)
+        for index, part in enumerate(value):
+            try:
+                self.base_field.run_validators(part)
+            except exceptions.ValidationError as error:
+                raise prefix_validation_error(
+                    error,
+                    prefix=self.error_messages["item_invalid"],
+                    code="item_invalid",
+                    params={"nth": index + 1},
+                )
+
+    def formfield(self, **kwargs):
+        return super().formfield(
+            **{
+                "form_class": SimpleArrayField,
+                "base_field": self.base_field.formfield(),
+                "max_length": self.size,
+                **kwargs,
+            }
+        )
+
+
+class ArrayRHSMixin:
+    def __init__(self, lhs, rhs):
+        if isinstance(rhs, (tuple, list)):
+            expressions = []
+            for value in rhs:
+                if not hasattr(value, "resolve_expression"):
+                    field = lhs.output_field
+                    value = Value(field.base_field.get_prep_value(value))
+                expressions.append(value)
+            rhs = Func(
+                *expressions,
+                function="ARRAY",
+                template="%(function)s[%(expressions)s]",
+            )
+        super().__init__(lhs, rhs)
+
+    def process_rhs(self, compiler, connection):
+        rhs, rhs_params = super().process_rhs(compiler, connection)
+        cast_type = self.lhs.output_field.cast_db_type(connection)
+        return "%s::%s" % (rhs, cast_type), rhs_params
+
+
+@ArrayField.register_lookup
+class ArrayContains(ArrayRHSMixin, lookups.DataContains):
+    pass
+
+
+@ArrayField.register_lookup
+class ArrayContainedBy(ArrayRHSMixin, lookups.ContainedBy):
+    pass
+
+
+@ArrayField.register_lookup
+class ArrayExact(ArrayRHSMixin, Exact):
+    pass
+
+
+@ArrayField.register_lookup
+class ArrayOverlap(ArrayRHSMixin, lookups.Overlap):
+    pass
+
+
+@ArrayField.register_lookup
+class ArrayLenTransform(Transform):
+    lookup_name = "len"
+    output_field = IntegerField()
+
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
+        # Distinguish NULL and empty arrays
+        return (
+            "CASE WHEN %(lhs)s IS NULL THEN NULL ELSE "
+            "coalesce(array_length(%(lhs)s, 1), 0) END"
+        ) % {"lhs": lhs}, params
+
+
+@ArrayField.register_lookup
+class ArrayInLookup(In):
+    def get_prep_lookup(self):
+        values = super().get_prep_lookup()
+        if hasattr(values, "resolve_expression"):
+            return values
+        # In.process_rhs() expects values to be hashable, so convert lists
+        # to tuples.
+        prepared_values = []
+        for value in values:
+            if hasattr(value, "resolve_expression"):
+                prepared_values.append(value)
+            else:
+                prepared_values.append(tuple(value))
+        return prepared_values
+
+
+class IndexTransform(Transform):
+    def __init__(self, index, base_field, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.index = index
+        self.base_field = base_field
+
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
+        return "%s[%%s]" % lhs, params + [self.index]
+
+    @property
+    def output_field(self):
+        return self.base_field
+
+
+class IndexTransformFactory:
+    def __init__(self, index, base_field):
+        self.index = index
+        self.base_field = base_field
+
+    def __call__(self, *args, **kwargs):
+        return IndexTransform(self.index, self.base_field, *args, **kwargs)
+
+
+class SliceTransform(Transform):
+    def __init__(self, start, end, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.start = start
+        self.end = end
+
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
+        return "%s[%%s:%%s]" % lhs, params + [self.start, self.end]
+
+
+class SliceTransformFactory:
+    def __init__(self, start, end):
+        self.start = start
+        self.end = end
+
+    def __call__(self, *args, **kwargs):
+        return SliceTransform(self.start, self.end, *args, **kwargs)

env/lib/python3.8/site-packages/django/contrib/postgres/fields/citext.py

@@ -0,0 +1,23 @@
+from django.db.models import CharField, EmailField, TextField
+
+__all__ = ["CICharField", "CIEmailField", "CIText", "CITextField"]
+
+
+class CIText:
+    def get_internal_type(self):
+        return "CI" + super().get_internal_type()
+
+    def db_type(self, connection):
+        return "citext"
+
+
+class CICharField(CIText, CharField):
+    pass
+
+
+class CIEmailField(CIText, EmailField):
+    pass
+
+
+class CITextField(CIText, TextField):
+    pass

env/lib/python3.8/site-packages/django/contrib/postgres/fields/hstore.py

@@ -0,0 +1,112 @@
+import json
+
+from django.contrib.postgres import forms, lookups
+from django.contrib.postgres.fields.array import ArrayField
+from django.core import exceptions
+from django.db.models import Field, TextField, Transform
+from django.db.models.fields.mixins import CheckFieldDefaultMixin
+from django.utils.translation import gettext_lazy as _
+
+__all__ = ["HStoreField"]
+
+
+class HStoreField(CheckFieldDefaultMixin, Field):
+    empty_strings_allowed = False
+    description = _("Map of strings to strings/nulls")
+    default_error_messages = {
+        "not_a_string": _("The value of “%(key)s” is not a string or null."),
+    }
+    _default_hint = ("dict", "{}")
+
+    def db_type(self, connection):
+        return "hstore"
+
+    def get_transform(self, name):
+        transform = super().get_transform(name)
+        if transform:
+            return transform
+        return KeyTransformFactory(name)
+
+    def validate(self, value, model_instance):
+        super().validate(value, model_instance)
+        for key, val in value.items():
+            if not isinstance(val, str) and val is not None:
+                raise exceptions.ValidationError(
+                    self.error_messages["not_a_string"],
+                    code="not_a_string",
+                    params={"key": key},
+                )
+
+    def to_python(self, value):
+        if isinstance(value, str):
+            value = json.loads(value)
+        return value
+
+    def value_to_string(self, obj):
+        return json.dumps(self.value_from_object(obj))
+
+    def formfield(self, **kwargs):
+        return super().formfield(
+            **{
+                "form_class": forms.HStoreField,
+                **kwargs,
+            }
+        )
+
+    def get_prep_value(self, value):
+        value = super().get_prep_value(value)
+
+        if isinstance(value, dict):
+            prep_value = {}
+            for key, val in value.items():
+                key = str(key)
+                if val is not None:
+                    val = str(val)
+                prep_value[key] = val
+            value = prep_value
+
+        if isinstance(value, list):
+            value = [str(item) for item in value]
+
+        return value
+
+
+HStoreField.register_lookup(lookups.DataContains)
+HStoreField.register_lookup(lookups.ContainedBy)
+HStoreField.register_lookup(lookups.HasKey)
+HStoreField.register_lookup(lookups.HasKeys)
+HStoreField.register_lookup(lookups.HasAnyKeys)
+
+
+class KeyTransform(Transform):
+    output_field = TextField()
+
+    def __init__(self, key_name, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.key_name = key_name
+
+    def as_sql(self, compiler, connection):
+        lhs, params = compiler.compile(self.lhs)
+        return "(%s -> %%s)" % lhs, tuple(params) + (self.key_name,)
+
+
+class KeyTransformFactory:
+    def __init__(self, key_name):
+        self.key_name = key_name
+
+    def __call__(self, *args, **kwargs):
+        return KeyTransform(self.key_name, *args, **kwargs)
+
+
+@HStoreField.register_lookup
+class KeysTransform(Transform):
+    lookup_name = "keys"
+    function = "akeys"
+    output_field = ArrayField(TextField())
+
+
+@HStoreField.register_lookup
+class ValuesTransform(Transform):
+    lookup_name = "values"
+    function = "avals"
+    output_field = ArrayField(TextField())

env/lib/python3.8/site-packages/django/contrib/postgres/fields/jsonb.py

@@ -0,0 +1,14 @@
+from django.db.models import JSONField as BuiltinJSONField
+
+__all__ = ["JSONField"]
+
+
+class JSONField(BuiltinJSONField):
+    system_check_removed_details = {
+        "msg": (
+            "django.contrib.postgres.fields.JSONField is removed except for "
+            "support in historical migrations."
+        ),
+        "hint": "Use django.db.models.JSONField instead.",
+        "id": "fields.E904",
+    }

env/lib/python3.8/site-packages/django/contrib/postgres/fields/ranges.py

@@ -0,0 +1,368 @@
+import datetime
+import json
+
+from psycopg2.extras import DateRange, DateTimeTZRange, NumericRange, Range
+
+from django.contrib.postgres import forms, lookups
+from django.db import models
+from django.db.models.lookups import PostgresOperatorLookup
+
+from .utils import AttributeSetter
+
+__all__ = [
+    "RangeField",
+    "IntegerRangeField",
+    "BigIntegerRangeField",
+    "DecimalRangeField",
+    "DateTimeRangeField",
+    "DateRangeField",
+    "RangeBoundary",
+    "RangeOperators",
+]
+
+
+class RangeBoundary(models.Expression):
+    """A class that represents range boundaries."""
+
+    def __init__(self, inclusive_lower=True, inclusive_upper=False):
+        self.lower = "[" if inclusive_lower else "("
+        self.upper = "]" if inclusive_upper else ")"
+
+    def as_sql(self, compiler, connection):
+        return "'%s%s'" % (self.lower, self.upper), []
+
+
+class RangeOperators:
+    # https://www.postgresql.org/docs/current/functions-range.html#RANGE-OPERATORS-TABLE
+    EQUAL = "="
+    NOT_EQUAL = "<>"
+    CONTAINS = "@>"
+    CONTAINED_BY = "<@"
+    OVERLAPS = "&&"
+    FULLY_LT = "<<"
+    FULLY_GT = ">>"
+    NOT_LT = "&>"
+    NOT_GT = "&<"
+    ADJACENT_TO = "-|-"
+
+
+class RangeField(models.Field):
+    empty_strings_allowed = False
+
+    def __init__(self, *args, **kwargs):
+        if "default_bounds" in kwargs:
+            raise TypeError(
+                f"Cannot use 'default_bounds' with {self.__class__.__name__}."
+            )
+        # Initializing base_field here ensures that its model matches the model
+        # for self.
+        if hasattr(self, "base_field"):
+            self.base_field = self.base_field()
+        super().__init__(*args, **kwargs)
+
+    @property
+    def model(self):
+        try:
+            return self.__dict__["model"]
+        except KeyError:
+            raise AttributeError(
+                "'%s' object has no attribute 'model'" % self.__class__.__name__
+            )
+
+    @model.setter
+    def model(self, model):
+        self.__dict__["model"] = model
+        self.base_field.model = model
+
+    @classmethod
+    def _choices_is_value(cls, value):
+        return isinstance(value, (list, tuple)) or super()._choices_is_value(value)
+
+    def get_prep_value(self, value):
+        if value is None:
+            return None
+        elif isinstance(value, Range):
+            return value
+        elif isinstance(value, (list, tuple)):
+            return self.range_type(value[0], value[1])
+        return value
+
+    def to_python(self, value):
+        if isinstance(value, str):
+            # Assume we're deserializing
+            vals = json.loads(value)
+            for end in ("lower", "upper"):
+                if end in vals:
+                    vals[end] = self.base_field.to_python(vals[end])
+            value = self.range_type(**vals)
+        elif isinstance(value, (list, tuple)):
+            value = self.range_type(value[0], value[1])
+        return value
+
+    def set_attributes_from_name(self, name):
+        super().set_attributes_from_name(name)
+        self.base_field.set_attributes_from_name(name)
+
+    def value_to_string(self, obj):
+        value = self.value_from_object(obj)
+        if value is None:
+            return None
+        if value.isempty:
+            return json.dumps({"empty": True})
+        base_field = self.base_field
+        result = {"bounds": value._bounds}
+        for end in ("lower", "upper"):
+            val = getattr(value, end)
+            if val is None:
+                result[end] = None
+            else:
+                obj = AttributeSetter(base_field.attname, val)
+                result[end] = base_field.value_to_string(obj)
+        return json.dumps(result)
+
+    def formfield(self, **kwargs):
+        kwargs.setdefault("form_class", self.form_field)
+        return super().formfield(**kwargs)
+
+
+CANONICAL_RANGE_BOUNDS = "[)"
+
+
+class ContinuousRangeField(RangeField):
+    """
+    Continuous range field. It allows specifying default bounds for list and
+    tuple inputs.
+    """
+
+    def __init__(self, *args, default_bounds=CANONICAL_RANGE_BOUNDS, **kwargs):
+        if default_bounds not in ("[)", "(]", "()", "[]"):
+            raise ValueError("default_bounds must be one of '[)', '(]', '()', or '[]'.")
+        self.default_bounds = default_bounds
+        super().__init__(*args, **kwargs)
+
+    def get_prep_value(self, value):
+        if isinstance(value, (list, tuple)):
+            return self.range_type(value[0], value[1], self.default_bounds)
+        return super().get_prep_value(value)
+
+    def formfield(self, **kwargs):
+        kwargs.setdefault("default_bounds", self.default_bounds)
+        return super().formfield(**kwargs)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.default_bounds and self.default_bounds != CANONICAL_RANGE_BOUNDS:
+            kwargs["default_bounds"] = self.default_bounds
+        return name, path, args, kwargs
+
+
+class IntegerRangeField(RangeField):
+    base_field = models.IntegerField
+    range_type = NumericRange
+    form_field = forms.IntegerRangeField
+
+    def db_type(self, connection):
+        return "int4range"
+
+
+class BigIntegerRangeField(RangeField):
+    base_field = models.BigIntegerField
+    range_type = NumericRange
+    form_field = forms.IntegerRangeField
+
+    def db_type(self, connection):
+        return "int8range"
+
+
+class DecimalRangeField(ContinuousRangeField):
+    base_field = models.DecimalField
+    range_type = NumericRange
+    form_field = forms.DecimalRangeField
+
+    def db_type(self, connection):
+        return "numrange"
+
+
+class DateTimeRangeField(ContinuousRangeField):
+    base_field = models.DateTimeField
+    range_type = DateTimeTZRange
+    form_field = forms.DateTimeRangeField
+
+    def db_type(self, connection):
+        return "tstzrange"
+
+
+class DateRangeField(RangeField):
+    base_field = models.DateField
+    range_type = DateRange
+    form_field = forms.DateRangeField
+
+    def db_type(self, connection):
+        return "daterange"
+
+
+RangeField.register_lookup(lookups.DataContains)
+RangeField.register_lookup(lookups.ContainedBy)
+RangeField.register_lookup(lookups.Overlap)
+
+
+class DateTimeRangeContains(PostgresOperatorLookup):
+    """
+    Lookup for Date/DateTimeRange containment to cast the rhs to the correct
+    type.
+    """
+
+    lookup_name = "contains"
+    postgres_operator = RangeOperators.CONTAINS
+
+    def process_rhs(self, compiler, connection):
+        # Transform rhs value for db lookup.
+        if isinstance(self.rhs, datetime.date):
+            value = models.Value(self.rhs)
+            self.rhs = value.resolve_expression(compiler.query)
+        return super().process_rhs(compiler, connection)
+
+    def as_postgresql(self, compiler, connection):
+        sql, params = super().as_postgresql(compiler, connection)
+        # Cast the rhs if needed.
+        cast_sql = ""
+        if (
+            isinstance(self.rhs, models.Expression)
+            and self.rhs._output_field_or_none
+            and
+            # Skip cast if rhs has a matching range type.
+            not isinstance(
+                self.rhs._output_field_or_none, self.lhs.output_field.__class__
+            )
+        ):
+            cast_internal_type = self.lhs.output_field.base_field.get_internal_type()
+            cast_sql = "::{}".format(connection.data_types.get(cast_internal_type))
+        return "%s%s" % (sql, cast_sql), params
+
+
+DateRangeField.register_lookup(DateTimeRangeContains)
+DateTimeRangeField.register_lookup(DateTimeRangeContains)
+
+
+class RangeContainedBy(PostgresOperatorLookup):
+    lookup_name = "contained_by"
+    type_mapping = {
+        "smallint": "int4range",
+        "integer": "int4range",
+        "bigint": "int8range",
+        "double precision": "numrange",
+        "numeric": "numrange",
+        "date": "daterange",
+        "timestamp with time zone": "tstzrange",
+    }
+    postgres_operator = RangeOperators.CONTAINED_BY
+
+    def process_rhs(self, compiler, connection):
+        rhs, rhs_params = super().process_rhs(compiler, connection)
+        # Ignore precision for DecimalFields.
+        db_type = self.lhs.output_field.cast_db_type(connection).split("(")[0]
+        cast_type = self.type_mapping[db_type]
+        return "%s::%s" % (rhs, cast_type), rhs_params
+
+    def process_lhs(self, compiler, connection):
+        lhs, lhs_params = super().process_lhs(compiler, connection)
+        if isinstance(self.lhs.output_field, models.FloatField):
+            lhs = "%s::numeric" % lhs
+        elif isinstance(self.lhs.output_field, models.SmallIntegerField):
+            lhs = "%s::integer" % lhs
+        return lhs, lhs_params
+
+    def get_prep_lookup(self):
+        return RangeField().get_prep_value(self.rhs)
+
+
+models.DateField.register_lookup(RangeContainedBy)
+models.DateTimeField.register_lookup(RangeContainedBy)
+models.IntegerField.register_lookup(RangeContainedBy)
+models.FloatField.register_lookup(RangeContainedBy)
+models.DecimalField.register_lookup(RangeContainedBy)
+
+
+@RangeField.register_lookup
+class FullyLessThan(PostgresOperatorLookup):
+    lookup_name = "fully_lt"
+    postgres_operator = RangeOperators.FULLY_LT
+
+
+@RangeField.register_lookup
+class FullGreaterThan(PostgresOperatorLookup):
+    lookup_name = "fully_gt"
+    postgres_operator = RangeOperators.FULLY_GT
+
+
+@RangeField.register_lookup
+class NotLessThan(PostgresOperatorLookup):
+    lookup_name = "not_lt"
+    postgres_operator = RangeOperators.NOT_LT
+
+
+@RangeField.register_lookup
+class NotGreaterThan(PostgresOperatorLookup):
+    lookup_name = "not_gt"
+    postgres_operator = RangeOperators.NOT_GT
+
+
+@RangeField.register_lookup
+class AdjacentToLookup(PostgresOperatorLookup):
+    lookup_name = "adjacent_to"
+    postgres_operator = RangeOperators.ADJACENT_TO
+
+
+@RangeField.register_lookup
+class RangeStartsWith(models.Transform):
+    lookup_name = "startswith"
+    function = "lower"
+
+    @property
+    def output_field(self):
+        return self.lhs.output_field.base_field
+
+
+@RangeField.register_lookup
+class RangeEndsWith(models.Transform):
+    lookup_name = "endswith"
+    function = "upper"
+
+    @property
+    def output_field(self):
+        return self.lhs.output_field.base_field
+
+
+@RangeField.register_lookup
+class IsEmpty(models.Transform):
+    lookup_name = "isempty"
+    function = "isempty"
+    output_field = models.BooleanField()
+
+
+@RangeField.register_lookup
+class LowerInclusive(models.Transform):
+    lookup_name = "lower_inc"
+    function = "LOWER_INC"
+    output_field = models.BooleanField()
+
+
+@RangeField.register_lookup
+class LowerInfinite(models.Transform):
+    lookup_name = "lower_inf"
+    function = "LOWER_INF"
+    output_field = models.BooleanField()
+
+
+@RangeField.register_lookup
+class UpperInclusive(models.Transform):
+    lookup_name = "upper_inc"
+    function = "UPPER_INC"
+    output_field = models.BooleanField()
+
+
+@RangeField.register_lookup
+class UpperInfinite(models.Transform):
+    lookup_name = "upper_inf"
+    function = "UPPER_INF"
+    output_field = models.BooleanField()

env/lib/python3.8/site-packages/django/contrib/postgres/fields/utils.py

@@ -0,0 +1,3 @@
+class AttributeSetter:
+    def __init__(self, name, value):
+        setattr(self, name, value)

env/lib/python3.8/site-packages/django/contrib/postgres/forms/__init__.py

@@ -0,0 +1,3 @@
+from .array import *  # NOQA
+from .hstore import *  # NOQA
+from .ranges import *  # NOQA

env/lib/python3.8/site-packages/django/contrib/postgres/forms/array.py

@@ -0,0 +1,251 @@
+import copy
+from itertools import chain
+
+from django import forms
+from django.contrib.postgres.validators import (
+    ArrayMaxLengthValidator,
+    ArrayMinLengthValidator,
+)
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+from ..utils import prefix_validation_error
+
+
+class SimpleArrayField(forms.CharField):
+    default_error_messages = {
+        "item_invalid": _("Item %(nth)s in the array did not validate:"),
+    }
+
+    def __init__(
+        self, base_field, *, delimiter=",", max_length=None, min_length=None, **kwargs
+    ):
+        self.base_field = base_field
+        self.delimiter = delimiter
+        super().__init__(**kwargs)
+        if min_length is not None:
+            self.min_length = min_length
+            self.validators.append(ArrayMinLengthValidator(int(min_length)))
+        if max_length is not None:
+            self.max_length = max_length
+            self.validators.append(ArrayMaxLengthValidator(int(max_length)))
+
+    def clean(self, value):
+        value = super().clean(value)
+        return [self.base_field.clean(val) for val in value]
+
+    def prepare_value(self, value):
+        if isinstance(value, list):
+            return self.delimiter.join(
+                str(self.base_field.prepare_value(v)) for v in value
+            )
+        return value
+
+    def to_python(self, value):
+        if isinstance(value, list):
+            items = value
+        elif value:
+            items = value.split(self.delimiter)
+        else:
+            items = []
+        errors = []
+        values = []
+        for index, item in enumerate(items):
+            try:
+                values.append(self.base_field.to_python(item))
+            except ValidationError as error:
+                errors.append(
+                    prefix_validation_error(
+                        error,
+                        prefix=self.error_messages["item_invalid"],
+                        code="item_invalid",
+                        params={"nth": index + 1},
+                    )
+                )
+        if errors:
+            raise ValidationError(errors)
+        return values
+
+    def validate(self, value):
+        super().validate(value)
+        errors = []
+        for index, item in enumerate(value):
+            try:
+                self.base_field.validate(item)
+            except ValidationError as error:
+                errors.append(
+                    prefix_validation_error(
+                        error,
+                        prefix=self.error_messages["item_invalid"],
+                        code="item_invalid",
+                        params={"nth": index + 1},
+                    )
+                )
+        if errors:
+            raise ValidationError(errors)
+
+    def run_validators(self, value):
+        super().run_validators(value)
+        errors = []
+        for index, item in enumerate(value):
+            try:
+                self.base_field.run_validators(item)
+            except ValidationError as error:
+                errors.append(
+                    prefix_validation_error(
+                        error,
+                        prefix=self.error_messages["item_invalid"],
+                        code="item_invalid",
+                        params={"nth": index + 1},
+                    )
+                )
+        if errors:
+            raise ValidationError(errors)
+
+    def has_changed(self, initial, data):
+        try:
+            value = self.to_python(data)
+        except ValidationError:
+            pass
+        else:
+            if initial in self.empty_values and value in self.empty_values:
+                return False
+        return super().has_changed(initial, data)
+
+
+class SplitArrayWidget(forms.Widget):
+    template_name = "postgres/widgets/split_array.html"
+
+    def __init__(self, widget, size, **kwargs):
+        self.widget = widget() if isinstance(widget, type) else widget
+        self.size = size
+        super().__init__(**kwargs)
+
+    @property
+    def is_hidden(self):
+        return self.widget.is_hidden
+
+    def value_from_datadict(self, data, files, name):
+        return [
+            self.widget.value_from_datadict(data, files, "%s_%s" % (name, index))
+            for index in range(self.size)
+        ]
+
+    def value_omitted_from_data(self, data, files, name):
+        return all(
+            self.widget.value_omitted_from_data(data, files, "%s_%s" % (name, index))
+            for index in range(self.size)
+        )
+
+    def id_for_label(self, id_):
+        # See the comment for RadioSelect.id_for_label()
+        if id_:
+            id_ += "_0"
+        return id_
+
+    def get_context(self, name, value, attrs=None):
+        attrs = {} if attrs is None else attrs
+        context = super().get_context(name, value, attrs)
+        if self.is_localized:
+            self.widget.is_localized = self.is_localized
+        value = value or []
+        context["widget"]["subwidgets"] = []
+        final_attrs = self.build_attrs(attrs)
+        id_ = final_attrs.get("id")
+        for i in range(max(len(value), self.size)):
+            try:
+                widget_value = value[i]
+            except IndexError:
+                widget_value = None
+            if id_:
+                final_attrs = {**final_attrs, "id": "%s_%s" % (id_, i)}
+            context["widget"]["subwidgets"].append(
+                self.widget.get_context(name + "_%s" % i, widget_value, final_attrs)[
+                    "widget"
+                ]
+            )
+        return context
+
+    @property
+    def media(self):
+        return self.widget.media
+
+    def __deepcopy__(self, memo):
+        obj = super().__deepcopy__(memo)
+        obj.widget = copy.deepcopy(self.widget)
+        return obj
+
+    @property
+    def needs_multipart_form(self):
+        return self.widget.needs_multipart_form
+
+
+class SplitArrayField(forms.Field):
+    default_error_messages = {
+        "item_invalid": _("Item %(nth)s in the array did not validate:"),
+    }
+
+    def __init__(self, base_field, size, *, remove_trailing_nulls=False, **kwargs):
+        self.base_field = base_field
+        self.size = size
+        self.remove_trailing_nulls = remove_trailing_nulls
+        widget = SplitArrayWidget(widget=base_field.widget, size=size)
+        kwargs.setdefault("widget", widget)
+        super().__init__(**kwargs)
+
+    def _remove_trailing_nulls(self, values):
+        index = None
+        if self.remove_trailing_nulls:
+            for i, value in reversed(list(enumerate(values))):
+                if value in self.base_field.empty_values:
+                    index = i
+                else:
+                    break
+            if index is not None:
+                values = values[:index]
+        return values, index
+
+    def to_python(self, value):
+        value = super().to_python(value)
+        return [self.base_field.to_python(item) for item in value]
+
+    def clean(self, value):
+        cleaned_data = []
+        errors = []
+        if not any(value) and self.required:
+            raise ValidationError(self.error_messages["required"])
+        max_size = max(self.size, len(value))
+        for index in range(max_size):
+            item = value[index]
+            try:
+                cleaned_data.append(self.base_field.clean(item))
+            except ValidationError as error:
+                errors.append(
+                    prefix_validation_error(
+                        error,
+                        self.error_messages["item_invalid"],
+                        code="item_invalid",
+                        params={"nth": index + 1},
+                    )
+                )
+                cleaned_data.append(None)
+            else:
+                errors.append(None)
+        cleaned_data, null_index = self._remove_trailing_nulls(cleaned_data)
+        if null_index is not None:
+            errors = errors[:null_index]
+        errors = list(filter(None, errors))
+        if errors:
+            raise ValidationError(list(chain.from_iterable(errors)))
+        return cleaned_data
+
+    def has_changed(self, initial, data):
+        try:
+            data = self.to_python(data)
+        except ValidationError:
+            pass
+        else:
+            data, _ = self._remove_trailing_nulls(data)
+            if initial in self.empty_values and data in self.empty_values:
+                return False
+        return super().has_changed(initial, data)

env/lib/python3.8/site-packages/django/contrib/postgres/forms/hstore.py

@@ -0,0 +1,59 @@
+import json
+
+from django import forms
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+__all__ = ["HStoreField"]
+
+
+class HStoreField(forms.CharField):
+    """
+    A field for HStore data which accepts dictionary JSON input.
+    """
+
+    widget = forms.Textarea
+    default_error_messages = {
+        "invalid_json": _("Could not load JSON data."),
+        "invalid_format": _("Input must be a JSON dictionary."),
+    }
+
+    def prepare_value(self, value):
+        if isinstance(value, dict):
+            return json.dumps(value)
+        return value
+
+    def to_python(self, value):
+        if not value:
+            return {}
+        if not isinstance(value, dict):
+            try:
+                value = json.loads(value)
+            except json.JSONDecodeError:
+                raise ValidationError(
+                    self.error_messages["invalid_json"],
+                    code="invalid_json",
+                )
+
+        if not isinstance(value, dict):
+            raise ValidationError(
+                self.error_messages["invalid_format"],
+                code="invalid_format",
+            )
+
+        # Cast everything to strings for ease.
+        for key, val in value.items():
+            if val is not None:
+                val = str(val)
+            value[key] = val
+        return value
+
+    def has_changed(self, initial, data):
+        """
+        Return True if data differs from initial.
+        """
+        # For purposes of seeing whether something has changed, None is
+        # the same as an empty dict, if the data or initial value we get
+        # is None, replace it w/ {}.
+        initial_value = self.to_python(initial)
+        return super().has_changed(initial_value, data)

env/lib/python3.8/site-packages/django/contrib/postgres/forms/ranges.py

@@ -0,0 +1,116 @@
+from psycopg2.extras import DateRange, DateTimeTZRange, NumericRange
+
+from django import forms
+from django.core import exceptions
+from django.forms.widgets import HiddenInput, MultiWidget
+from django.utils.translation import gettext_lazy as _
+
+__all__ = [
+    "BaseRangeField",
+    "IntegerRangeField",
+    "DecimalRangeField",
+    "DateTimeRangeField",
+    "DateRangeField",
+    "HiddenRangeWidget",
+    "RangeWidget",
+]
+
+
+class RangeWidget(MultiWidget):
+    def __init__(self, base_widget, attrs=None):
+        widgets = (base_widget, base_widget)
+        super().__init__(widgets, attrs)
+
+    def decompress(self, value):
+        if value:
+            return (value.lower, value.upper)
+        return (None, None)
+
+
+class HiddenRangeWidget(RangeWidget):
+    """A widget that splits input into two <input type="hidden"> inputs."""
+
+    def __init__(self, attrs=None):
+        super().__init__(HiddenInput, attrs)
+
+
+class BaseRangeField(forms.MultiValueField):
+    default_error_messages = {
+        "invalid": _("Enter two valid values."),
+        "bound_ordering": _(
+            "The start of the range must not exceed the end of the range."
+        ),
+    }
+    hidden_widget = HiddenRangeWidget
+
+    def __init__(self, **kwargs):
+        if "widget" not in kwargs:
+            kwargs["widget"] = RangeWidget(self.base_field.widget)
+        if "fields" not in kwargs:
+            kwargs["fields"] = [
+                self.base_field(required=False),
+                self.base_field(required=False),
+            ]
+        kwargs.setdefault("required", False)
+        kwargs.setdefault("require_all_fields", False)
+        self.range_kwargs = {}
+        if default_bounds := kwargs.pop("default_bounds", None):
+            self.range_kwargs = {"bounds": default_bounds}
+        super().__init__(**kwargs)
+
+    def prepare_value(self, value):
+        lower_base, upper_base = self.fields
+        if isinstance(value, self.range_type):
+            return [
+                lower_base.prepare_value(value.lower),
+                upper_base.prepare_value(value.upper),
+            ]
+        if value is None:
+            return [
+                lower_base.prepare_value(None),
+                upper_base.prepare_value(None),
+            ]
+        return value
+
+    def compress(self, values):
+        if not values:
+            return None
+        lower, upper = values
+        if lower is not None and upper is not None and lower > upper:
+            raise exceptions.ValidationError(
+                self.error_messages["bound_ordering"],
+                code="bound_ordering",
+            )
+        try:
+            range_value = self.range_type(lower, upper, **self.range_kwargs)
+        except TypeError:
+            raise exceptions.ValidationError(
+                self.error_messages["invalid"],
+                code="invalid",
+            )
+        else:
+            return range_value
+
+
+class IntegerRangeField(BaseRangeField):
+    default_error_messages = {"invalid": _("Enter two whole numbers.")}
+    base_field = forms.IntegerField
+    range_type = NumericRange
+
+
+class DecimalRangeField(BaseRangeField):
+    default_error_messages = {"invalid": _("Enter two numbers.")}
+    base_field = forms.DecimalField
+    range_type = NumericRange
+
+
+class DateTimeRangeField(BaseRangeField):
+    default_error_messages = {"invalid": _("Enter two valid date/times.")}
+    base_field = forms.DateTimeField
+    range_type = DateTimeTZRange
+
+
+class DateRangeField(BaseRangeField):
+    default_error_messages = {"invalid": _("Enter two valid dates.")}
+    base_field = forms.DateField
+    range_type = DateRange

env/lib/python3.8/site-packages/django/contrib/postgres/functions.py

@@ -0,0 +1,11 @@
+from django.db.models import DateTimeField, Func, UUIDField
+
+
+class RandomUUID(Func):
+    template = "GEN_RANDOM_UUID()"
+    output_field = UUIDField()
+
+
+class TransactionNow(Func):
+    template = "CURRENT_TIMESTAMP"
+    output_field = DateTimeField()

env/lib/python3.8/site-packages/django/contrib/postgres/indexes.py

@@ -0,0 +1,249 @@
+from django.db import NotSupportedError
+from django.db.models import Func, Index
+from django.utils.functional import cached_property
+
+__all__ = [
+    "BloomIndex",
+    "BrinIndex",
+    "BTreeIndex",
+    "GinIndex",
+    "GistIndex",
+    "HashIndex",
+    "SpGistIndex",
+]
+
+
+class PostgresIndex(Index):
+    @cached_property
+    def max_name_length(self):
+        # Allow an index name longer than 30 characters when the suffix is
+        # longer than the usual 3 character limit. The 30 character limit for
+        # cross-database compatibility isn't applicable to PostgreSQL-specific
+        # indexes.
+        return Index.max_name_length - len(Index.suffix) + len(self.suffix)
+
+    def create_sql(self, model, schema_editor, using="", **kwargs):
+        self.check_supported(schema_editor)
+        statement = super().create_sql(
+            model, schema_editor, using=" USING %s" % (using or self.suffix), **kwargs
+        )
+        with_params = self.get_with_params()
+        if with_params:
+            statement.parts["extra"] = " WITH (%s)%s" % (
+                ", ".join(with_params),
+                statement.parts["extra"],
+            )
+        return statement
+
+    def check_supported(self, schema_editor):
+        pass
+
+    def get_with_params(self):
+        return []
+
+
+class BloomIndex(PostgresIndex):
+    suffix = "bloom"
+
+    def __init__(self, *expressions, length=None, columns=(), **kwargs):
+        super().__init__(*expressions, **kwargs)
+        if len(self.fields) > 32:
+            raise ValueError("Bloom indexes support a maximum of 32 fields.")
+        if not isinstance(columns, (list, tuple)):
+            raise ValueError("BloomIndex.columns must be a list or tuple.")
+        if len(columns) > len(self.fields):
+            raise ValueError("BloomIndex.columns cannot have more values than fields.")
+        if not all(0 < col <= 4095 for col in columns):
+            raise ValueError(
+                "BloomIndex.columns must contain integers from 1 to 4095.",
+            )
+        if length is not None and not 0 < length <= 4096:
+            raise ValueError(
+                "BloomIndex.length must be None or an integer from 1 to 4096.",
+            )
+        self.length = length
+        self.columns = columns
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        if self.length is not None:
+            kwargs["length"] = self.length
+        if self.columns:
+            kwargs["columns"] = self.columns
+        return path, args, kwargs
+
+    def get_with_params(self):
+        with_params = []
+        if self.length is not None:
+            with_params.append("length = %d" % self.length)
+        if self.columns:
+            with_params.extend(
+                "col%d = %d" % (i, v) for i, v in enumerate(self.columns, start=1)
+            )
+        return with_params
+
+
+class BrinIndex(PostgresIndex):
+    suffix = "brin"
+
+    def __init__(
+        self, *expressions, autosummarize=None, pages_per_range=None, **kwargs
+    ):
+        if pages_per_range is not None and pages_per_range <= 0:
+            raise ValueError("pages_per_range must be None or a positive integer")
+        self.autosummarize = autosummarize
+        self.pages_per_range = pages_per_range
+        super().__init__(*expressions, **kwargs)
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        if self.autosummarize is not None:
+            kwargs["autosummarize"] = self.autosummarize
+        if self.pages_per_range is not None:
+            kwargs["pages_per_range"] = self.pages_per_range
+        return path, args, kwargs
+
+    def get_with_params(self):
+        with_params = []
+        if self.autosummarize is not None:
+            with_params.append(
+                "autosummarize = %s" % ("on" if self.autosummarize else "off")
+            )
+        if self.pages_per_range is not None:
+            with_params.append("pages_per_range = %d" % self.pages_per_range)
+        return with_params
+
+
+class BTreeIndex(PostgresIndex):
+    suffix = "btree"
+
+    def __init__(self, *expressions, fillfactor=None, **kwargs):
+        self.fillfactor = fillfactor
+        super().__init__(*expressions, **kwargs)
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        if self.fillfactor is not None:
+            kwargs["fillfactor"] = self.fillfactor
+        return path, args, kwargs
+
+    def get_with_params(self):
+        with_params = []
+        if self.fillfactor is not None:
+            with_params.append("fillfactor = %d" % self.fillfactor)
+        return with_params
+
+
+class GinIndex(PostgresIndex):
+    suffix = "gin"
+
+    def __init__(
+        self, *expressions, fastupdate=None, gin_pending_list_limit=None, **kwargs
+    ):
+        self.fastupdate = fastupdate
+        self.gin_pending_list_limit = gin_pending_list_limit
+        super().__init__(*expressions, **kwargs)
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        if self.fastupdate is not None:
+            kwargs["fastupdate"] = self.fastupdate
+        if self.gin_pending_list_limit is not None:
+            kwargs["gin_pending_list_limit"] = self.gin_pending_list_limit
+        return path, args, kwargs
+
+    def get_with_params(self):
+        with_params = []
+        if self.gin_pending_list_limit is not None:
+            with_params.append(
+                "gin_pending_list_limit = %d" % self.gin_pending_list_limit
+            )
+        if self.fastupdate is not None:
+            with_params.append("fastupdate = %s" % ("on" if self.fastupdate else "off"))
+        return with_params
+
+
+class GistIndex(PostgresIndex):
+    suffix = "gist"
+
+    def __init__(self, *expressions, buffering=None, fillfactor=None, **kwargs):
+        self.buffering = buffering
+        self.fillfactor = fillfactor
+        super().__init__(*expressions, **kwargs)
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        if self.buffering is not None:
+            kwargs["buffering"] = self.buffering
+        if self.fillfactor is not None:
+            kwargs["fillfactor"] = self.fillfactor
+        return path, args, kwargs
+
+    def get_with_params(self):
+        with_params = []
+        if self.buffering is not None:
+            with_params.append("buffering = %s" % ("on" if self.buffering else "off"))
+        if self.fillfactor is not None:
+            with_params.append("fillfactor = %d" % self.fillfactor)
+        return with_params
+
+    def check_supported(self, schema_editor):
+        if (
+            self.include
+            and not schema_editor.connection.features.supports_covering_gist_indexes
+        ):
+            raise NotSupportedError("Covering GiST indexes require PostgreSQL 12+.")
+
+
+class HashIndex(PostgresIndex):
+    suffix = "hash"
+
+    def __init__(self, *expressions, fillfactor=None, **kwargs):
+        self.fillfactor = fillfactor
+        super().__init__(*expressions, **kwargs)
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        if self.fillfactor is not None:
+            kwargs["fillfactor"] = self.fillfactor
+        return path, args, kwargs
+
+    def get_with_params(self):
+        with_params = []
+        if self.fillfactor is not None:
+            with_params.append("fillfactor = %d" % self.fillfactor)
+        return with_params
+
+
+class SpGistIndex(PostgresIndex):
+    suffix = "spgist"
+
+    def __init__(self, *expressions, fillfactor=None, **kwargs):
+        self.fillfactor = fillfactor
+        super().__init__(*expressions, **kwargs)
+
+    def deconstruct(self):
+        path, args, kwargs = super().deconstruct()
+        if self.fillfactor is not None:
+            kwargs["fillfactor"] = self.fillfactor
+        return path, args, kwargs
+
+    def get_with_params(self):
+        with_params = []
+        if self.fillfactor is not None:
+            with_params.append("fillfactor = %d" % self.fillfactor)
+        return with_params
+
+    def check_supported(self, schema_editor):
+        if (
+            self.include
+            and not schema_editor.connection.features.supports_covering_spgist_indexes
+        ):
+            raise NotSupportedError("Covering SP-GiST indexes require PostgreSQL 14+.")
+
+
+class OpClass(Func):
+    template = "%(expressions)s %(name)s"
+
+    def __init__(self, expression, name):
+        super().__init__(expression, name=name)

env/lib/python3.8/site-packages/django/contrib/postgres/jinja2/postgres/widgets/split_array.html

@@ -0,0 +1 @@
+{% include 'django/forms/widgets/multiwidget.html' %}

env/lib/python3.8/site-packages/django/contrib/postgres/locale/af/LC_MESSAGES/django.po

@@ -0,0 +1,104 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# F Wolff <friedel@translate.org.za>, 2019-2020
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Afrikaans (http://www.transifex.com/django/django/language/"
+"af/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: af\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL-uitbreidings"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Item %(nth)s in die skikking kon nie valideer nie:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Geneste skikkings moet dieselfde lengte hê."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Woordeboek van stringe na stringe/nulls"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Die waarde “%(key)s” is nie 'n string of null nie."
+
+msgid "Could not load JSON data."
+msgstr "Kon nie JSON-data laai nie."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Toevoer moet 'n JSON-woordeboek wees."
+
+msgid "Enter two valid values."
+msgstr "Gee twee geldige waardes."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Die begin van die omvang mag nie die einde van die omvang oorskry nie."
+
+msgid "Enter two whole numbers."
+msgstr "Tik twee heelgetalle in."
+
+msgid "Enter two numbers."
+msgstr "Tik twee getalle in."
+
+msgid "Enter two valid date/times."
+msgstr "Tik twee geldige datum/tydwaardes in."
+
+msgid "Enter two valid dates."
+msgstr "Tik twee geldige datums in."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Lys bevat %(show_value)d item, maar moet hoogstens %(limit_value)d bevat."
+msgstr[1] ""
+"Lys bevat %(show_value)d items, maar moet hoogstens %(limit_value)d bevat."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Lys bevat %(show_value)d item, maar moet minstens %(limit_value)d bevat."
+msgstr[1] ""
+"Lys bevat %(show_value)d items, maar moet minstens %(limit_value)d bevat."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Sommige sleutels het ontbreek: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Sommige onbekende sleutels is voorsien: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Maak seker dat dié omvang heeltemal kleiner of gelyk is aan %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Maak seker dat dié omvang heeltemal groter of gelyk is aan %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/ar/LC_MESSAGES/django.po

@@ -0,0 +1,131 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Bashar Al-Abdulhadi, 2015-2017
+# Muaaz Alsaied, 2020
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Arabic (http://www.transifex.com/django/django/language/ar/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: ar\n"
+"Plural-Forms: nplurals=6; plural=n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 "
+"&& n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5;\n"
+
+msgid "PostgreSQL extensions"
+msgstr "ملحقات PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "العنصر %(nth)s في المتسلسلة لم يحقق التالي: "
+
+msgid "Nested arrays must have the same length."
+msgstr "يجب أن تكون المجموعات المتداخلة بنفس الطول."
+
+msgid "Map of strings to strings/nulls"
+msgstr "ترابط strings بـ strings/nulls"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "قيمة \"%(key)s\" ليست string أو null."
+
+msgid "Could not load JSON data."
+msgstr "لا يمكن عرض بيانات JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "المُدخل يجب أن يكون بصيغة بصيغة قاموس JSON."
+
+msgid "Enter two valid values."
+msgstr "إدخال قيمتين صالحتين."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "بداية المدى يجب ألا تتجاوز نهاية المدى."
+
+msgid "Enter two whole numbers."
+msgstr "أدخل رقمين كاملين."
+
+msgid "Enter two numbers."
+msgstr "أدخل رقمين."
+
+msgid "Enter two valid date/times."
+msgstr "أدخل تاريخين/وقتين صحيحين."
+
+msgid "Enter two valid dates."
+msgstr "أدخل تاريخين صحيحين."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[1] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[2] ""
+"القائمة تحتوي على %(show_value)d عنصرين, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[3] ""
+"القائمة تحتوي على %(show_value)d عناصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[4] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[5] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[1] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[2] ""
+"القائمة تحتوي على %(show_value)d عنصرين, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[3] ""
+"القائمة تحتوي على %(show_value)d عناصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[4] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[5] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "بعض المفاتيح مفقودة: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "بعض المفاتيح المزوّدة غير معرّفه: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "تأكد من أن هذا المدى أقل من أو يساوي %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr "تأكد من أن هذا المدى أكثر من أو يساوي %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/ar_DZ/LC_MESSAGES/django.po

@@ -0,0 +1,131 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Riterix <infosrabah@gmail.com>, 2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Arabic (Algeria) (http://www.transifex.com/django/django/"
+"language/ar_DZ/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: ar_DZ\n"
+"Plural-Forms: nplurals=6; plural=n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 "
+"&& n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5;\n"
+
+msgid "PostgreSQL extensions"
+msgstr "ملحقات PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "العنصر %(nth)s في المجموعة لم يتم التحقق منه: "
+
+msgid "Nested arrays must have the same length."
+msgstr "يجب أن تكون المجموعات المتداخلة بنفس الطول."
+
+msgid "Map of strings to strings/nulls"
+msgstr "خريطة السلاسل إلى سلاسل / بلا قيم"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "قيمة \\\"%(key)s\\\" ليست سلسلة أو بلا قيمة."
+
+msgid "Could not load JSON data."
+msgstr "لا يمكن عرض بيانات JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "المُدخل يجب أن يكون بصيغة بصيغة قاموس JSON."
+
+msgid "Enter two valid values."
+msgstr "إدخال قيمتين صالحتين."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "بداية المدى يجب ألا تتجاوز نهاية المدى."
+
+msgid "Enter two whole numbers."
+msgstr "أدخل رقمين كاملين."
+
+msgid "Enter two numbers."
+msgstr "أدخل رقمين."
+
+msgid "Enter two valid date/times."
+msgstr "أدخل تاريخين/وقتين صحيحين."
+
+msgid "Enter two valid dates."
+msgstr "أدخل تاريخين صحيحين."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[1] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[2] ""
+"القائمة تحتوي على %(show_value)d عنصرين, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[3] ""
+"القائمة تحتوي على %(show_value)d عناصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[4] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+msgstr[5] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أكثر من "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[1] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[2] ""
+"القائمة تحتوي على %(show_value)d عنصرين, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[3] ""
+"القائمة تحتوي على %(show_value)d عناصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[4] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+msgstr[5] ""
+"القائمة تحتوي على %(show_value)d عنصر, يجب أن لا تحتوي على أقل من "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "بعض المفاتيح مفقودة: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "بعض المفاتيح المزوّدة غير معرّفه: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "تأكد من أن هذا المدى أقل من أو يساوي %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr "تأكد من أن هذا المدى أكثر من أو يساوي %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/az/LC_MESSAGES/django.po

@@ -0,0 +1,102 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Emin Mastizada <emin@linux.com>, 2018,2020
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Azerbaijani (http://www.transifex.com/django/django/language/"
+"az/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: az\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL uzantıları"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Array-dəki %(nth)s element təsdiqlənə bilmir:"
+
+msgid "Nested arrays must have the same length."
+msgstr "İç-içə array-lərin uzunluğu eyni olmalıdır."
+
+msgid "Map of strings to strings/nulls"
+msgstr "String-lərin string/null-lara xəritələnmə cədvəli"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "“%(key)s” dəyəri string və ya null deyil."
+
+msgid "Could not load JSON data."
+msgstr "JSON məlumat yüklənə bilmir."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Giriş JSON lüğət olmalıdır."
+
+msgid "Enter two valid values."
+msgstr "İki düzgün dəyər daxil edin."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Aralığın başlanğıcı bitişindən böyük ola bilməz."
+
+msgid "Enter two whole numbers."
+msgstr "İki tam rəqəm daxil edin."
+
+msgid "Enter two numbers."
+msgstr "İki rəqəm daxil edin."
+
+msgid "Enter two valid date/times."
+msgstr "İki düzgün tarix/vaxt daxil edin."
+
+msgid "Enter two valid dates."
+msgstr "İki düzgün tarix daxil edin."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Siyahıda %(show_value)d element var, ən çox %(limit_value)d ola bilər."
+msgstr[1] ""
+"Siyahıda %(show_value)d element var, ən çox %(limit_value)d ola bilər."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Siyahıda %(show_value)d element var, ən az %(limit_value)d ola bilər."
+msgstr[1] ""
+"Siyahıda %(show_value)d element var, ən az %(limit_value)d ola bilər."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Bəzi açarlar əksikdir: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Bəzi bilinməyən açarlar təchiz edilib: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "Bu aralığın %(limit_value)s və ya daha az olduğuna əmin olun."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr "Bu aralığın %(limit_value)s və ya daha böyük olduğuna əmin olun."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/be/LC_MESSAGES/django.po

@@ -0,0 +1,122 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Viktar Palstsiuk <vipals@gmail.com>, 2015
+# znotdead <zhirafchik@gmail.com>, 2016-2017,2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Belarusian (http://www.transifex.com/django/django/language/"
+"be/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: be\n"
+"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
+"%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || (n"
+"%100>=11 && n%100<=14)? 2 : 3);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Пашырэнні PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Элемент масіву нумар %(nth)s не прайшоў праверкі:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Укладзенныя масівы павінны мець аднолькавую даўжыню."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Адпаведнасць радкоў у радкі/нулі"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Значэнне “%(key)s” не з'яўляецца радком ці null."
+
+msgid "Could not load JSON data."
+msgstr "Не атрымалася загрузіць дадзеныя JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Значэнне павінна быць JSON слоўнікам. "
+
+msgid "Enter two valid values."
+msgstr "Увядзіце два сапраўдных значэнні."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Пачатак дыяпазону не павінен перавышаць канец дыяпазону."
+
+msgid "Enter two whole numbers."
+msgstr "Увядзіце два цэлых лікі."
+
+msgid "Enter two numbers."
+msgstr "Увядзіце два лікі."
+
+msgid "Enter two valid date/times."
+msgstr "Увядзіце дзве/два сапраўдных даты/часу."
+
+msgid "Enter two valid dates."
+msgstr "Увядзіце дзве сапраўдных даты."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Спіс мае %(show_value)d элемент, ён павінен мець не болей чым "
+"%(limit_value)d."
+msgstr[1] ""
+"Спіс мае %(show_value)d элемента, ён павінен мець не болей чым "
+"%(limit_value)d."
+msgstr[2] ""
+"Спіс мае %(show_value)d элементаў, ён павінен мець не болей чым "
+"%(limit_value)d."
+msgstr[3] ""
+"Спіс мае %(show_value)d элементаў, ён павінен мець не болей чым "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Спіс мае %(show_value)d элемент, ён павінен мець не менш чым %(limit_value)d."
+msgstr[1] ""
+"Спіс мае %(show_value)d элемента, ён павінен мець не менш чым "
+"%(limit_value)d."
+msgstr[2] ""
+"Спіс мае %(show_value)d элементаў, ён павінен мець не менш чым "
+"%(limit_value)d."
+msgstr[3] ""
+"Спіс мае %(show_value)d элементаў, ён павінен мець не менш чым "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Не хапае нейкіх ключоў: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Дадзены нейкія невядомыя ключы: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Упэўніцеся, что ўсе элементы гэтага інтэрвалу менш ці раўны %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Упэўніцеся, что ўсе элементы гэтага інтэрвалу больш ці раўны %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/bg/LC_MESSAGES/django.po

@@ -0,0 +1,110 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# arneatec <arneatec@gmail.com>, 2022
+# Todor Lubenov <tlubenov@gmail.com>, 2015
+# Venelin Stoykov <vkstoykov@gmail.com>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2022-01-14 11:54+0000\n"
+"Last-Translator: arneatec <arneatec@gmail.com>\n"
+"Language-Team: Bulgarian (http://www.transifex.com/django/django/language/"
+"bg/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: bg\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL разширения"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Елемент %(nth)s в масива не се валидира:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Вложените масиви трябва да имат еднаква дължина."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Мап от стрингове към стрингове/null-ове"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Стойността на “%(key)s” не е стринг или null."
+
+msgid "Could not load JSON data."
+msgstr "Не можа да зареди JSON данни."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Входните данни трябва да са JSON речник."
+
+msgid "Enter two valid values."
+msgstr "Въведете две валидни стойности."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Началото на обхвата не трябва да превишава края му."
+
+msgid "Enter two whole numbers."
+msgstr "Въведете две цели числа."
+
+msgid "Enter two numbers."
+msgstr "Въведете две числа."
+
+msgid "Enter two valid date/times."
+msgstr "Въведете две валидни дати/времена."
+
+msgid "Enter two valid dates."
+msgstr "Въведете две коректни дати."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Списъкът съдържа %(show_value)d елемент, а трябва да има не повече от "
+"%(limit_value)d."
+msgstr[1] ""
+"Списъкът съдържа %(show_value)d елемента, а трябва да има не повече от "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Списъкът съдържа %(show_value)d елемент, а трябва да има поне "
+"%(limit_value)d."
+msgstr[1] ""
+"Списъкът съдържа %(show_value)d елемента, а трябва да има поне "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Някои ключове липсват: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Бяха предоставени някои неизвестни ключове: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Уверете се, че този обхват е изцяло по-малък от или равен на %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Уверете се, че интервалът е изцяло по-голям от или равен на %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/ca/LC_MESSAGES/django.po

@@ -0,0 +1,112 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Antoni Aloy <aaloy@apsl.net>, 2015,2017
+# duub qnnp, 2015
+# Gil Obradors Via <gil.obradors@gmail.com>, 2019
+# Manel Clos <manelclos@gmail.com>, 2020
+# Roger Pons <rogerpons@gmail.com>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Catalan (http://www.transifex.com/django/django/language/"
+"ca/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: ca\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Extensions de PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "L'element %(nth)s de la matriu no s'ha pogut validar:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Les matrius niades han de tenir la mateixa longitud."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Mapa de cadenes a cadenes/nuls"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "El valor de \"%(key)s\" no és ni una cadena ni un nul."
+
+msgid "Could not load JSON data."
+msgstr "No es poden carregar les dades JSON"
+
+msgid "Input must be a JSON dictionary."
+msgstr "L'entrada ha de ser un diccionari JSON"
+
+msgid "Enter two valid values."
+msgstr "Introdueixi dos valors vàlids."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "L'inici del rang no pot excedir el seu final."
+
+msgid "Enter two whole numbers."
+msgstr "Introduïu dos números enters positius."
+
+msgid "Enter two numbers."
+msgstr "Introduïu dos números."
+
+msgid "Enter two valid date/times."
+msgstr "Introduïu dues data/hora vàlides."
+
+msgid "Enter two valid dates."
+msgstr "Introduïu dos dates vàlides."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"La llista conté %(show_value)d element, no n'hauria de tenir més de "
+"%(limit_value)d."
+msgstr[1] ""
+"La llista conté %(show_value)d elements, no n'hauria de tenir més de "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"La llista conté %(show_value)d element, no n'hauria de contenir menys de "
+"%(limit_value)d."
+msgstr[1] ""
+"La llista conté %(show_value)d elements, no n'hauria de contenir menys de "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Algunes claus no hi són: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "S'han facilitat claus desconegudes: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Asseguri's que aquest rang és completament menor o igual a %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Asseguri's que aquest rang és completament major o igual a %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/cs/LC_MESSAGES/django.po

@@ -0,0 +1,119 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Tomáš Ehrlich <tomas.ehrlich@gmail.com>, 2015
+# Vláďa Macek <macek@sandbox.cz>, 2015-2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Czech (http://www.transifex.com/django/django/language/cs/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: cs\n"
+"Plural-Forms: nplurals=4; plural=(n == 1 && n % 1 == 0) ? 0 : (n >= 2 && n "
+"<= 4 && n % 1 == 0) ? 1: (n % 1 != 0 ) ? 2 : 3;\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Rozšíření pro PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Položka č. %(nth)s v seznamu je neplatná:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Vnořená pole musejí mít stejnou délku."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Mapování řetězců na řetězce či hodnoty NULL"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Hodnota s klíčem \"%(key)s\" není řetězec ani NULL."
+
+msgid "Could not load JSON data."
+msgstr "Data typu JSON nelze načíst."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Vstup musí být slovník formátu JSON."
+
+msgid "Enter two valid values."
+msgstr "Zadejte dvě platné hodnoty."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Počáteční hodnota rozsahu nemůže být vyšší než koncová hodnota."
+
+msgid "Enter two whole numbers."
+msgstr "Zadejte dvě celá čísla."
+
+msgid "Enter two numbers."
+msgstr "Zadejte dvě čísla."
+
+msgid "Enter two valid date/times."
+msgstr "Zadejte dvě platné hodnoty data nebo času."
+
+msgid "Enter two valid dates."
+msgstr "Zadejte dvě platná data."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Seznam obsahuje %(show_value)d položku, ale neměl by obsahovat více než "
+"%(limit_value)d."
+msgstr[1] ""
+"Seznam obsahuje %(show_value)d položky, ale neměl by obsahovat více než "
+"%(limit_value)d."
+msgstr[2] ""
+"Seznam obsahuje %(show_value)d položek, ale neměl by obsahovat více než "
+"%(limit_value)d."
+msgstr[3] ""
+"Seznam obsahuje %(show_value)d položek, ale neměl by obsahovat více než "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Seznam obsahuje %(show_value)d položku, ale neměl by obsahovat méně než "
+"%(limit_value)d."
+msgstr[1] ""
+"Seznam obsahuje %(show_value)d položky, ale neměl by obsahovat méně než "
+"%(limit_value)d."
+msgstr[2] ""
+"Seznam obsahuje %(show_value)d položek, ale neměl by obsahovat méně než "
+"%(limit_value)d."
+msgstr[3] ""
+"Seznam obsahuje %(show_value)d položek, ale neměl by obsahovat méně než "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Některé klíče chybí: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Byly zadány neznámé klíče: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "Nejvyšší hodnota rozsahu musí být menší nebo rovna %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr "Nejnižší hodnota rozsahu musí být větší nebo rovna %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/da/LC_MESSAGES/django.po

@@ -0,0 +1,110 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Erik Ramsgaard Wognsen <r4mses@gmail.com>, 2015-2020
+# valberg <valberg@orn.li>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-13 20:35+0000\n"
+"Last-Translator: Erik Ramsgaard Wognsen <r4mses@gmail.com>\n"
+"Language-Team: Danish (http://www.transifex.com/django/django/language/da/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: da\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL-udvidelser"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Element %(nth)s i array'et blev ikke valideret:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Indlejrede arrays skal have den samme længde."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Afbildning fra strenge til strenge/nulls"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Værdien af “%(key)s” er ikke en streng eller null."
+
+msgid "Could not load JSON data."
+msgstr "Kunne ikke indlæse JSON-data."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Input skal være et JSON-dictionary."
+
+msgid "Enter two valid values."
+msgstr "Indtast to gyldige værdier."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Starten af intervallet kan ikke overstige slutningen af intervallet."
+
+msgid "Enter two whole numbers."
+msgstr "Indtast to heltal."
+
+msgid "Enter two numbers."
+msgstr "Indtast to tal."
+
+msgid "Enter two valid date/times."
+msgstr "Indtast to gyldige dato/tider."
+
+msgid "Enter two valid dates."
+msgstr "Indtast to gyldige datoer."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Listen indeholder %(show_value)d element, en bør ikke indeholde mere end "
+"%(limit_value)d."
+msgstr[1] ""
+"Listen indeholder %(show_value)d elementer, den bør ikke indeholde mere end "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Listen indeholder %(show_value)d element, den bør ikke indeholde mindre end "
+"%(limit_value)d."
+msgstr[1] ""
+"Listen indeholder %(show_value)d elementer, den bør ikke indeholde mindre "
+"end %(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Nøgler mangler: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Ukendte nøgler angivet: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Sørg for at dette interval er fuldstændigt mindre end eller lig med "
+"%(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Sørg for at dette interval er fuldstændigt større end eller lig med "
+"%(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/de/LC_MESSAGES/django.po

@@ -0,0 +1,107 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Jannis Leidel <jannis@leidel.info>, 2015-2018,2020
+# Jens Neuhaus <kontakt@jensneuhaus.de>, 2016
+# Markus Holtermann <info@markusholtermann.eu>, 2017
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: German (http://www.transifex.com/django/django/language/de/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: de\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL-Erweiterungen"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Element %(nth)s im Array konnte nicht validiert werden:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Verschachtelte Arrays müssen die gleiche Länge haben."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Zuordnung von Zeichenketten zu Zeichenketten/NULLs"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Der Wert für „%(key)s“ ist keine Zeichenkette oder NULL."
+
+msgid "Could not load JSON data."
+msgstr "Konnte JSON-Daten nicht laden."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Eingabe muss ein JSON-Dictionary sein."
+
+msgid "Enter two valid values."
+msgstr "Bitte zwei gültige Werte eingeben."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Der Anfang des Wertbereichs darf nicht das Ende überschreiten."
+
+msgid "Enter two whole numbers."
+msgstr "Bitte zwei ganze Zahlen eingeben."
+
+msgid "Enter two numbers."
+msgstr "Bitte zwei Zahlen eingeben."
+
+msgid "Enter two valid date/times."
+msgstr "Bitte zwei gültige Datum/Uhrzeit-Werte eingeben."
+
+msgid "Enter two valid dates."
+msgstr "Bitte zwei gültige Kalenderdaten eingeben."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Liste enthält %(show_value)d Element, es sollte aber nicht mehr als "
+"%(limit_value)d enthalten."
+msgstr[1] ""
+"Liste enthält %(show_value)d Elemente, es sollte aber nicht mehr als "
+"%(limit_value)d enthalten."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Liste enthält %(show_value)d Element, es sollte aber nicht weniger als "
+"%(limit_value)d enthalten."
+msgstr[1] ""
+"Liste enthält %(show_value)d Elemente, es sollte aber nicht weniger als "
+"%(limit_value)d enthalten."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Einige Werte fehlen: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Einige unbekannte Werte wurden eingegeben: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "Der Wertebereich muss kleiner oder gleich zu %(limit_value)s sein."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr "Der Wertebereich muss größer oder gleich zu %(limit_value)s sein."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/dsb/LC_MESSAGES/django.po

@@ -0,0 +1,121 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Michael Wolf <milupo@sorbzilla.de>, 2016-2018,2020
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Lower Sorbian (http://www.transifex.com/django/django/"
+"language/dsb/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: dsb\n"
+"Plural-Forms: nplurals=4; plural=(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n"
+"%100==4 ? 2 : 3);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Rozšyrjenja PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Zapisk %(nth)sw pólnej wariabli njejo se wobkšuśił:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Zakašćikowane pólne wariable muse tu samsku dłujkosć měś."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Konwertěrowanje znamuškowych rjeśazkow do znamuškowych rjeśazkow/nulow"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Gódnota „%(key)s“ njejo znamuškowy rjeśazk abo null."
+
+msgid "Could not load JSON data."
+msgstr "JSON-daty njejsu se zacytowaś dali."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Zapódaśe musy JSON-słownik byś."
+
+msgid "Enter two valid values."
+msgstr "Zapódajśo dwě płaśiwej gódnośe."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Zachopjeńk wobcerka njesmějo kóńc wobcerka pśekšocyś."
+
+msgid "Enter two whole numbers."
+msgstr "Zapódajśo dwě cełej licbje."
+
+msgid "Enter two numbers."
+msgstr "Zapódajśo dwě licbje."
+
+msgid "Enter two valid date/times."
+msgstr "Zapódajśo dwě płaśiwej datowej/casowej pódaśi."
+
+msgid "Enter two valid dates."
+msgstr "Zapódajśo dwě płaśiwej datowej pódaśi."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Lisćina wopśimujo %(show_value)d element, wóna njeby dejała wěcej ako "
+"%(limit_value)d wopśimowaś."
+msgstr[1] ""
+"Lisćina wopśimujo %(show_value)d elementa, wóna njeby dejała wěcej ako "
+"%(limit_value)d wopśimowaś."
+msgstr[2] ""
+"Lisćina wopśimujo %(show_value)d elementy, wóna njeby dejała wěcej ako "
+"%(limit_value)d wopśimowaś."
+msgstr[3] ""
+"Lisćina wopśimujo %(show_value)d elementow, wóna njeby dejała wěcej ako "
+"%(limit_value)d wopśimowaś."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Lisćina wopśimujo %(show_value)d element, wóna njeby dejała mjenjej ako "
+"%(limit_value)d wopśimowaś."
+msgstr[1] ""
+"Lisćina wopśimujo %(show_value)d elementa, wóna njeby dejała mjenjej ako "
+"%(limit_value)d wopśimowaś."
+msgstr[2] ""
+"Lisćina wopśimujo %(show_value)d elementy, wóna njeby dejała mjenjej ako "
+"%(limit_value)d wopśimowaś."
+msgstr[3] ""
+"Lisćina wopśimujo %(show_value)d elementow, wóna njeby dejała mjenjej ako "
+"%(limit_value)d wopśimowaś."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Někotare kluce feluju: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Někotare njeznate kluce su se pódali: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Zawěsććo, až toś ten wobcerk jo mjeńšy ako %(limit_value)s abo se rowna."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Zawěsććo, až toś ten wobcerk jo wětšy ako %(limit_value)s abo se rowna."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/el/LC_MESSAGES/django.po

@@ -0,0 +1,111 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Fotis Athineos <fotis@transifex.com>, 2021
+# Giannis Meletakis <meletakis@gmail.com>, 2015
+# Nick Mavrakis <mavrakis.n@gmail.com>, 2017-2018
+# Nick Mavrakis <mavrakis.n@gmail.com>, 2016
+# Pãnoș <panos.laganakos@gmail.com>, 2016
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2021-08-04 06:26+0000\n"
+"Last-Translator: Fotis Athineos <fotis@transifex.com>\n"
+"Language-Team: Greek (http://www.transifex.com/django/django/language/el/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: el\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Επεκτάσεις της PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "To στοιχείο %(nth)s στον πίνακα δεν είναι έγκυρο:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Οι ένθετοι πίνακες πρέπει να έχουν το ίδιο μήκος."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Αντιστοίχιση strings σε strings/nulls"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Η τιμή του “%(key)s“ δεν είναι string ή null."
+
+msgid "Could not load JSON data."
+msgstr "Αδύνατη η φόρτωση των δεδομένων JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Το input πρέπει να είναι ένα έγκυρο JSON dictionary."
+
+msgid "Enter two valid values."
+msgstr "Εισάγετε δύο έγκυρες τιμές."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Η αρχή του range δεν πρέπει να ξεπερνά το τέλος του range."
+
+msgid "Enter two whole numbers."
+msgstr "Εισάγετε δυο ολόκληρους αριθμούς."
+
+msgid "Enter two numbers."
+msgstr "Εισάγετε δυο αριθμούς."
+
+msgid "Enter two valid date/times."
+msgstr "Εισάγετε δύο έγκυρες ημερομηνίες/ώρες."
+
+msgid "Enter two valid dates."
+msgstr "Εισάγετε δυο έγκυρες ημερομηνίες."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Η λίστα περιέχει %(show_value)d στοιχείο και δεν πρέπει να περιέχει πάνω από "
+"%(limit_value)d."
+msgstr[1] ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Η λίστα περιέχει %(show_value)d στοιχεία και δεν πρέπει να περιέχει λιγότερα "
+"από %(limit_value)d."
+msgstr[1] ""
+"Η λίστα περιέχει %(show_value)d στοιχεία και δεν πρέπει να περιέχει λιγότερα "
+"από %(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Έλειπαν μερικά κλειδιά: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Δόθηκαν μέρικά άγνωστα κλειδιά: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Βεβαιωθείτε ότι το range είναι αυστηρά μικρότερο ή ίσο από %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Βεβαιωθείτε ότι το range είναι αυστηρά μεγαλύτερο ή ίσο από %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/en/LC_MESSAGES/django.po

@@ -0,0 +1,115 @@
+# This file is distributed under the same license as the Django package.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2015-01-18 20:56+0100\n"
+"Last-Translator: Django team\n"
+"Language-Team: English <en@li.org>\n"
+"Language: en\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: contrib/postgres/apps.py:42
+msgid "PostgreSQL extensions"
+msgstr ""
+
+#: contrib/postgres/fields/array.py:21 contrib/postgres/forms/array.py:16
+#: contrib/postgres/forms/array.py:170
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr ""
+
+#: contrib/postgres/fields/array.py:22
+msgid "Nested arrays must have the same length."
+msgstr ""
+
+#: contrib/postgres/fields/hstore.py:15
+msgid "Map of strings to strings/nulls"
+msgstr ""
+
+#: contrib/postgres/fields/hstore.py:17
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr ""
+
+#: contrib/postgres/forms/hstore.py:16
+msgid "Could not load JSON data."
+msgstr ""
+
+#: contrib/postgres/forms/hstore.py:17
+msgid "Input must be a JSON dictionary."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:33
+msgid "Enter two valid values."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:34
+msgid "The start of the range must not exceed the end of the range."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:82
+msgid "Enter two whole numbers."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:88
+msgid "Enter two numbers."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:94
+msgid "Enter two valid date/times."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:100
+msgid "Enter two valid dates."
+msgstr ""
+
+#: contrib/postgres/validators.py:12
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+msgstr[1] ""
+
+#: contrib/postgres/validators.py:19
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+msgstr[1] ""
+
+#: contrib/postgres/validators.py:29
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr ""
+
+#: contrib/postgres/validators.py:30
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr ""
+
+#: contrib/postgres/validators.py:70
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+
+#: contrib/postgres/validators.py:76
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""

env/lib/python3.8/site-packages/django/contrib/postgres/locale/en_AU/LC_MESSAGES/django.po

@@ -0,0 +1,109 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Tom Fifield <tom@tomfifield.net>, 2021
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2021-04-11 13:16+0000\n"
+"Last-Translator: Tom Fifield <tom@tomfifield.net>\n"
+"Language-Team: English (Australia) (http://www.transifex.com/django/django/"
+"language/en_AU/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: en_AU\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL extensions"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Item %(nth)s in the array did not validate:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Nested arrays must have the same length."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Map of strings to strings/nulls"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "The value of “%(key)s” is not a string or null."
+
+msgid "Could not load JSON data."
+msgstr "Could not load JSON data."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Input must be a JSON dictionary."
+
+msgid "Enter two valid values."
+msgstr "Enter two valid values."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "The start of the range must not exceed the end of the range."
+
+msgid "Enter two whole numbers."
+msgstr "Enter two whole numbers."
+
+msgid "Enter two numbers."
+msgstr "Enter two numbers."
+
+msgid "Enter two valid date/times."
+msgstr "Enter two valid date/times."
+
+msgid "Enter two valid dates."
+msgstr "Enter two valid dates."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgstr[1] ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[1] ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Some keys were missing: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Some unknown keys were provided: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/eo/LC_MESSAGES/django.po

@@ -0,0 +1,109 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Baptiste Darthenay <baptiste+transifex@darthenay.fr>, 2015-2017,2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Esperanto (http://www.transifex.com/django/django/language/"
+"eo/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: eo\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL kromaĵoj"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Elemento %(nth)s en la tabelo ne estas valida:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Ingitaj tabeloj devas havi la saman grandon."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Kongruo de signoĉenoj al signoĉenoj/nulvaloroj"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr ""
+
+msgid "Could not load JSON data."
+msgstr "Malsukcesis ŝarĝi la JSON datumojn."
+
+msgid "Input must be a JSON dictionary."
+msgstr "La enigo devas esti JSON vortaro."
+
+msgid "Enter two valid values."
+msgstr "Enigu du validajn valorojn."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "La komenco de la intervalo ne devas superi la finon de la intervalo."
+
+msgid "Enter two whole numbers."
+msgstr "Enigu du entjeroj."
+
+msgid "Enter two numbers."
+msgstr "Enigu du nombroj."
+
+msgid "Enter two valid date/times."
+msgstr "Enigu du validajn dato/horojn."
+
+msgid "Enter two valid dates."
+msgstr "Enigu du validajn datojn."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"La listo enhavas %(show_value)d eron, kaj ne devas enhavi pli ol "
+"%(limit_value)d."
+msgstr[1] ""
+"La listo enhavas %(show_value)d erojn, kaj ne devas enhavi pli ol "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"La listo enhavas %(show_value)d erojn, kaj devas enhavi pli ol "
+"%(limit_value)d."
+msgstr[1] ""
+"La listo enhavas %(show_value)d erojn, kaj devas enhavi pli ol "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Kelkaj ŝlosiloj mankas: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Kelkaj nekonataj ŝlosiloj estis provizitaj: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Bv kontroli, ke la tuta intervalo estas malpli alta aŭ egala al "
+"%(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Bv kontroli, ke la tuta intervalo estas pli alta aŭ egala al %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/es/LC_MESSAGES/django.po

@@ -0,0 +1,114 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Antoni Aloy <aaloy@apsl.net>, 2015,2017
+# Ernesto Avilés, 2015
+# Ignacio José Lizarán Rus <ilizaran@gmail.com>, 2019
+# Igor Támara <igor@tamarapatino.org>, 2015
+# Pablo, 2015
+# Uriel Medina <urimeba511@gmail.com>, 2020
+# Veronicabh <vero.blazher@gmail.com>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-09-25 17:40+0000\n"
+"Last-Translator: Uriel Medina <urimeba511@gmail.com>\n"
+"Language-Team: Spanish (http://www.transifex.com/django/django/language/"
+"es/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: es\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Extensiones de PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "El elemento %(nth)s del arreglo no se pudo validar:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Los arreglos anidados deben tener la misma longitud."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Mapa de cadenas a cadenas/nulos"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "El valor de “%(key)s” no es una cadena ni es nulo."
+
+msgid "Could not load JSON data."
+msgstr "No se pududieron cargar los datos JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "La entrada debe ser un diccionario JSON"
+
+msgid "Enter two valid values."
+msgstr "Introduzca dos valores válidos."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "El comienzo del rango no puede exceder su final."
+
+msgid "Enter two whole numbers."
+msgstr "Ingrese dos números enteros."
+
+msgid "Enter two numbers."
+msgstr "Ingrese dos números."
+
+msgid "Enter two valid date/times."
+msgstr "Ingrese dos fechas/horas válidas."
+
+msgid "Enter two valid dates."
+msgstr "Ingrese dos fechas válidas."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"La lista contiene %(show_value)d elemento, no debería contener más de "
+"%(limit_value)d."
+msgstr[1] ""
+"La lista contiene %(show_value)d elementos, no debería contener más de "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"La lista contiene %(show_value)d elemento, no debería contener menos de "
+"%(limit_value)d."
+msgstr[1] ""
+"La lista contiene %(show_value)d elementos, no debería contener menos de "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Faltan algunas claves: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Se facilitaron algunas claves desconocidas: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "Asegúrese de que este rango es menor o igual que %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Asegúrese de que este rango es efectivamente mayor o igual que "
+"%(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/es_AR/LC_MESSAGES/django.po

@@ -0,0 +1,108 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Ramiro Morales, 2015-2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Spanish (Argentina) (http://www.transifex.com/django/django/"
+"language/es_AR/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: es_AR\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Extensiones PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "La validación del ítem %(nth)s del arreglo falló:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Los arreglos anidados deben ser de la misma longitud."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Mapa de cadenas a cadenas/nulos"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "El valor de \"%(key)s” no es una cadena o nulo."
+
+msgid "Could not load JSON data."
+msgstr "No se han podido cargar los datos JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "debe ser un diccionario JSON."
+
+msgid "Enter two valid values."
+msgstr "Introduzca dos valores válidos."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "El inicio del rango no debe ser mayor que el fin del rango."
+
+msgid "Enter two whole numbers."
+msgstr "Introduzca dos números enteros."
+
+msgid "Enter two numbers."
+msgstr "Introduzca dos números."
+
+msgid "Enter two valid date/times."
+msgstr "Introduzca dos fechas/horas válidas."
+
+msgid "Enter two valid dates."
+msgstr "Introduzca dos fechas válidas."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"La lista contiene %(show_value)d ítem, debe contener no mas de "
+"%(limit_value)d."
+msgstr[1] ""
+"La lista contiene %(show_value)d ítems, debe contener no mas de "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"La lista contiene %(show_value)d ítem, debe contener no mas de "
+"%(limit_value)d."
+msgstr[1] ""
+"La lista contiene %(show_value)d ítems, debe contener no menos de "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "No se encontraron algunas llaves: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Algunas de las llaves provistas son desconocidas: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Asegúrese de que este rango es completamente menor o igual a %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Asegúrese de que este rango es completamente mayor o igual a %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/es_CO/LC_MESSAGES/django.po

@@ -0,0 +1,112 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Antoni Aloy <aaloy@apsl.net>, 2015
+# Ernesto Avilés, 2015
+# Igor Támara <igor@tamarapatino.org>, 2015
+# Pablo, 2015
+# Veronicabh <vero.blazher@gmail.com>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Spanish (Colombia) (http://www.transifex.com/django/django/"
+"language/es_CO/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: es_CO\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Extensiones de PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr ""
+
+msgid "Nested arrays must have the same length."
+msgstr "Los arreglos anidados deben tener la misma longitud."
+
+msgid "Map of strings to strings/nulls"
+msgstr ""
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr ""
+
+msgid "Could not load JSON data."
+msgstr "No se pududieron cargar los datos JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr ""
+
+msgid "Enter two valid values."
+msgstr "Ingrese dos valores válidos."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "El comienzo del rango no puede exceder su final."
+
+msgid "Enter two whole numbers."
+msgstr "Ingrese dos números enteros."
+
+msgid "Enter two numbers."
+msgstr "Ingrese dos números."
+
+msgid "Enter two valid date/times."
+msgstr "Ingrese dos fechas/horas válidas."
+
+msgid "Enter two valid dates."
+msgstr "Ingrese dos fechas válidas."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"La lista contiene %(show_value)d elemento, no debería contener más de "
+"%(limit_value)d."
+msgstr[1] ""
+"La lista contiene %(show_value)d elementos, no debería contener más de "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"La lista contiene %(show_value)d elemento, no debería contener menos de "
+"%(limit_value)d."
+msgstr[1] ""
+"La lista contiene %(show_value)d elementos, no debería contener menos de "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Faltan algunas claves: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Se facilitaron algunas claves desconocidas: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "Asegúrese de que este rango es menor o igual que %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Asegúrese de que este rango es efectivamente mayor o igual que "
+"%(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/es_MX/LC_MESSAGES/django.po

@@ -0,0 +1,98 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Alex Dzul <alexexc2@gmail.com>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Spanish (Mexico) (http://www.transifex.com/django/django/"
+"language/es_MX/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: es_MX\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Extensiones PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr ""
+
+msgid "Nested arrays must have the same length."
+msgstr ""
+
+msgid "Map of strings to strings/nulls"
+msgstr ""
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr ""
+
+msgid "Could not load JSON data."
+msgstr ""
+
+msgid "Input must be a JSON dictionary."
+msgstr ""
+
+msgid "Enter two valid values."
+msgstr "Ingrese dos valores válidos"
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr ""
+
+msgid "Enter two whole numbers."
+msgstr ""
+
+msgid "Enter two numbers."
+msgstr "Ingrese dos números"
+
+msgid "Enter two valid date/times."
+msgstr ""
+
+msgid "Enter two valid dates."
+msgstr "Ingrese dos fechas válidas"
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+msgstr[1] ""
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+msgstr[1] ""
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr ""
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr ""
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""

env/lib/python3.8/site-packages/django/contrib/postgres/locale/et/LC_MESSAGES/django.po

@@ -0,0 +1,111 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Martin Pajuste <martinpajuste@gmail.com>, 2015
+# Martin Pajuste <martinpajuste@gmail.com>, 2017
+# Marti Raudsepp <marti@juffo.org>, 2015-2016
+# Ragnar Rebase <rrebase@gmail.com>, 2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Estonian (http://www.transifex.com/django/django/language/"
+"et/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: et\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL laiendused"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Element %(nth)s massiivis pole korrektne:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Mitmemõõtmelised massiivid peavad olema sama pikad."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Teisendus sõnedest sõnedeks/tühjadeks"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Võtme “%(key)s” väärtus ei ole sõne ega tühi."
+
+msgid "Could not load JSON data."
+msgstr "Ei saanud laadida JSON andmeid."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Sisend peab olema JSON sõnastik."
+
+msgid "Enter two valid values."
+msgstr "Sisesta kaks korrektset väärtust."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Vahemiku algus ei või olla suurem kui vahemiku lõpp."
+
+msgid "Enter two whole numbers."
+msgstr "Sisesta kaks täisarvu."
+
+msgid "Enter two numbers."
+msgstr "Sisesta kaks arvu."
+
+msgid "Enter two valid date/times."
+msgstr "Sisesta kaks korrektset kuupäeva ja kellaaega."
+
+msgid "Enter two valid dates."
+msgstr "Sisesta kaks korrektset kuupäeva."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Nimekiri sisaldab %(show_value)d elementi, ei tohiks olla rohkem kui "
+"%(limit_value)d."
+msgstr[1] ""
+"Nimekiri sisaldab %(show_value)d elementi, ei tohiks olla rohkem kui "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Nimekiri sisaldab %(show_value)d elementi, ei tohiks olla vähem kui "
+"%(limit_value)d."
+msgstr[1] ""
+"Nimekiri sisaldab %(show_value)d elementi, ei tohiks olla vähem kui "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Puuduvad võtmeväärtused: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Tundmatud võtmeväärtused: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Veendu, et see vahemik on täielikult väiksem või võrdne kui %(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Veendu, et see vahemik on täielikult suurem või võrdne kui %(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/eu/LC_MESSAGES/django.po

@@ -0,0 +1,108 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Eneko Illarramendi <eneko@illarra.com>, 2017-2018
+# Urtzi Odriozola <urtzi.odriozola@gmail.com>, 2017,2021
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2021-03-18 15:48+0000\n"
+"Last-Translator: Urtzi Odriozola <urtzi.odriozola@gmail.com>\n"
+"Language-Team: Basque (http://www.transifex.com/django/django/language/eu/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: eu\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL hedapenak"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Array-ko %(nth)s elementua ez da balekoa:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Array habiaratuek luzera bera izan behar dute."
+
+msgid "Map of strings to strings/nulls"
+msgstr "String-etik string/null-era mapa"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "”%(key)s”-ren balioa ez da string bat, edo null."
+
+msgid "Could not load JSON data."
+msgstr "Ezin izan dira JSON datuak kargatu."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Sarrera JSON hiztegi bat izan behar da."
+
+msgid "Enter two valid values."
+msgstr "Idatzi bi baleko balio."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Tartearen hasierak ezin du amaierako tartearen balioa gainditu."
+
+msgid "Enter two whole numbers."
+msgstr "Idatzi bi zenbaki oso."
+
+msgid "Enter two numbers."
+msgstr "Idatzi bi zenbaki."
+
+msgid "Enter two valid date/times."
+msgstr "Idatzi bi baleko data/ordu."
+
+msgid "Enter two valid dates."
+msgstr "Idatzi bi baleko data."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Zerrendak elementu %(show_value)d du, ez lituzke %(limit_value)dbaino "
+"gehiago izan behar."
+msgstr[1] ""
+"Zerrendak %(show_value)d elementu ditu, ez lituzke %(limit_value)d baino "
+"gehiago izan behar."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Zerrendak elementu %(show_value)d du, ez lituzke %(limit_value)d baino "
+"gutxiago izan behar."
+msgstr[1] ""
+"Zerrendak %(show_value)d elementu ditu, ez lituzke %(limit_value)d baino "
+"gutxiago izan behar."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Gako batzuk falta dira: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Gako ezezagun batzuk eman dira: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Ziurtatu guztiz tarte hau %(limit_value)s baino txikiagoa edo berdina dela."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Ziurtatu guztiz tarte hau %(limit_value)s baino handiagoa edo berdina dela."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/fa/LC_MESSAGES/django.po

@@ -0,0 +1,108 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Ali Nikneshan <ali@nikneshan.com>, 2015
+# MJafar Mashhadi <raindigital2007@gmail.com>, 2018
+# Mohammad Hossein Mojtahedi <Mhm5000@gmail.com>, 2016
+# Pouya Abbassi, 2016
+# rahim agh <rahim.aghareb@gmail.com>, 2020
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-27 09:32+0000\n"
+"Last-Translator: rahim agh <rahim.aghareb@gmail.com>\n"
+"Language-Team: Persian (http://www.transifex.com/django/django/language/"
+"fa/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: fa\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "ملحقات Postgres"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "عضو %(nth)sم آرایه معتبر نیست:"
+
+msgid "Nested arrays must have the same length."
+msgstr "آرایه های تو در تو باید هم سایز باشند"
+
+msgid "Map of strings to strings/nulls"
+msgstr "نگاشتی از رشته به رشته/هیچمقدار"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "مقدار \"%(key)s\" یک رشته حرفی یا null نیست."
+
+msgid "Could not load JSON data."
+msgstr "امکان بارگزاری  داده های JSON  نیست."
+
+msgid "Input must be a JSON dictionary."
+msgstr "مقدار ورودی باید یک دیکشنری JSON باشد."
+
+msgid "Enter two valid values."
+msgstr "دو مقدار معتبر وارد کنید"
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "مقدار شروع بازه باید از پایان کوچکتر باشد"
+
+msgid "Enter two whole numbers."
+msgstr "دو عدد کامل وارد کنید"
+
+msgid "Enter two numbers."
+msgstr "دو عدد وارد کنید"
+
+msgid "Enter two valid date/times."
+msgstr "دو تاریخ/ساعت معتبر وارد کنید"
+
+msgid "Enter two valid dates."
+msgstr "دو تاریخ معتبر وارد کنید"
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"لیست شامل %(show_value)d مورد است. ولی باید حداکثر شامل %(limit_value)d مورد "
+"باشد."
+msgstr[1] ""
+"لیست شامل %(show_value)d مورد است. ولی باید حداکثر شامل %(limit_value)d مورد "
+"باشد."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"لیست شامل %(show_value)d است، نباید کمتر از %(limit_value)d را شامل شود."
+msgstr[1] ""
+"لیست شامل %(show_value)d است، نباید کمتر از %(limit_value)d را شامل شود."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "برخی کلیدها یافت نشدند: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "برخی کلیدهای ارائه شده ناشناخته‌اند: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr "اطمیمنان حاصل کنید که این رنج، کوچکتر یا برابر با %(limit_value)s است."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr "اطمینان حاصل کنید که رنج، بزرگتر یا برابر با %(limit_value)s است."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/fi/LC_MESSAGES/django.po

@@ -0,0 +1,110 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Aarni Koskela, 2015,2017,2020
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-12-09 06:30+0000\n"
+"Last-Translator: Aarni Koskela\n"
+"Language-Team: Finnish (http://www.transifex.com/django/django/language/"
+"fi/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: fi\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "PostgreSQL-laajennukset"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Taulukon %(nth)s alkio ei ole kelvollinen:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Sisäkkäisillä taulukoilla tulee olla sama pituus."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Kartta merkkijonoista merkkijonoihin tai tyhjiin (null)"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Avaimen \"%(key)s\" arvo ei ole merkkijono tai tyhjä (null)."
+
+msgid "Could not load JSON data."
+msgstr "JSON-dataa ei voitu ladata."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Syötteen tulee olla JSON-sanakirja."
+
+msgid "Enter two valid values."
+msgstr "Anna kaksi oikeaa arvoa."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Alueen alku pitää olla pienempi kuin alueen loppu."
+
+msgid "Enter two whole numbers."
+msgstr "Anna kaksi kokonaislukua."
+
+msgid "Enter two numbers."
+msgstr "Anna kaksi lukua."
+
+msgid "Enter two valid date/times."
+msgstr "Anna kaksi oikeaa päivämäärää/kellonaikaa."
+
+msgid "Enter two valid dates."
+msgstr "Anna kaksi oikeaa päivämäärää."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Listassa on %(show_value)d arvo, mutta siinä ei saa olla enempää kuin "
+"%(limit_value)d."
+msgstr[1] ""
+"Listassa on %(show_value)d arvoa, mutta siinä ei saa olla enempää kuin "
+"%(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Listassa on %(show_value)d arvo, mutta siinä ei saa olla vähempää kuin "
+"%(limit_value)d arvoa."
+msgstr[1] ""
+"Listassa on %(show_value)d arvoa, mutta siinä ei saa olla vähempää kuin "
+"%(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Joitain avaimia puuttuu: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Tuntemattomia avaimia annettiin: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Tämän alueen tulee olla kokonaisuudessaan yhtäsuuri tai pienempi kuin "
+"%(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Tämän alueen tulee olla kokonaisuudessaan yhtäsuuri tai suurempi kuin "
+"%(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/fr/LC_MESSAGES/django.po

@@ -0,0 +1,109 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Claude Paroz <claude@2xlibre.net>, 2015-2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: French (http://www.transifex.com/django/django/language/fr/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: fr\n"
+"Plural-Forms: nplurals=2; plural=(n > 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Extensions PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "L'élément n°%(nth)s du tableau n’est pas valide :"
+
+msgid "Nested arrays must have the same length."
+msgstr "Les tableaux imbriqués doivent être de même longueur."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Correspondances clé/valeur (chaînes ou valeurs nulles)"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "La valeur de « %(key)s » n’est pas une chaîne, ni une valeur nulle."
+
+msgid "Could not load JSON data."
+msgstr "Impossible de charger les données JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Le contenu saisi doit être un dictionnaire JSON."
+
+msgid "Enter two valid values."
+msgstr "Saisissez deux valeurs valides."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Le début de l’intervalle ne peut pas dépasser la fin de l'intervalle."
+
+msgid "Enter two whole numbers."
+msgstr "Saisissez deux nombres entiers."
+
+msgid "Enter two numbers."
+msgstr "Saisissez deux nombres."
+
+msgid "Enter two valid date/times."
+msgstr "Saisissez deux dates/heures valides."
+
+msgid "Enter two valid dates."
+msgstr "Saisissez deux dates valides."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"La liste contient %(show_value)d élément, mais elle ne devrait pas en "
+"contenir plus de %(limit_value)d."
+msgstr[1] ""
+"La liste contient %(show_value)d éléments, mais elle ne devrait pas en "
+"contenir plus de %(limit_value)d."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"La liste contient %(show_value)d élément, mais elle doit en contenir au "
+"moins %(limit_value)d."
+msgstr[1] ""
+"La liste contient %(show_value)d éléments, mais elle doit en contenir au "
+"moins %(limit_value)d."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Certaines clés sont manquantes : %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Certaines clés inconnues ont été fournies : %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Assurez-vous que cet intervalle est entièrement inférieur ou égal à "
+"%(limit_value)s."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Assurez-vous que cet intervalle est entièrement supérieur ou égal à "
+"%(limit_value)s."

env/lib/python3.8/site-packages/django/contrib/postgres/locale/gd/LC_MESSAGES/django.po

@@ -0,0 +1,125 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# GunChleoc, 2016-2017
+# GunChleoc, 2015
+# GunChleoc, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2020-05-11 20:56+0200\n"
+"PO-Revision-Date: 2020-05-12 20:01+0000\n"
+"Last-Translator: Transifex Bot <>\n"
+"Language-Team: Gaelic, Scottish (http://www.transifex.com/django/django/"
+"language/gd/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: gd\n"
+"Plural-Forms: nplurals=4; plural=(n==1 || n==11) ? 0 : (n==2 || n==12) ? 1 : "
+"(n > 2 && n < 20) ? 2 : 3;\n"
+
+msgid "PostgreSQL extensions"
+msgstr "Leudachain PostgreSQL"
+
+#, python-format
+msgid "Item %(nth)s in the array did not validate:"
+msgstr "Cha deach le dearbhadh an nì %(nth)s san arraigh:"
+
+msgid "Nested arrays must have the same length."
+msgstr "Feumaidh an aon fhaid a bhith aig a h-uile arraigh neadaichte."
+
+msgid "Map of strings to strings/nulls"
+msgstr "Mapaichean de shreangan gu sreangan/luachan null"
+
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr "Chan eil an luach air %(key)s ’na shreang no null."
+
+msgid "Could not load JSON data."
+msgstr "Cha deach leinn dàta JSON a luchdadh."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Feumaidh an t-ion-chur a bhith 'na fhaclair JSON."
+
+msgid "Enter two valid values."
+msgstr "Cuir a-steach dà luach dligheach."
+
+msgid "The start of the range must not exceed the end of the range."
+msgstr "Chan fhaod toiseach na rainse a bith nas motha na deireadh na rainse."
+
+msgid "Enter two whole numbers."
+msgstr "Cuir a-steach dà àireamh shlàn."
+
+msgid "Enter two numbers."
+msgstr "Cuir a-steach dà àireamh."
+
+msgid "Enter two valid date/times."
+msgstr "Cuir a-steach dà cheann-là ’s àm dligheach."
+
+msgid "Enter two valid dates."
+msgstr "Cuir a-steach dà cheann-là dligheach."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no more than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no more than "
+"%(limit_value)d."
+msgstr[0] ""
+"Tha %(show_value)d nì air an liosta ach cha bu chòir corr is %(limit_value)d "
+"a bhith oirre."
+msgstr[1] ""
+"Tha %(show_value)d nì air an liosta ach cha bu chòir corr is %(limit_value)d "
+"a bhith oirre."
+msgstr[2] ""
+"Tha %(show_value)d nithean air an liosta ach cha bu chòir corr is "
+"%(limit_value)d a bhith oirre."
+msgstr[3] ""
+"Tha %(show_value)d nì air an liosta ach cha bu chòir corr is %(limit_value)d "
+"a bhith oirre."
+
+#, python-format
+msgid ""
+"List contains %(show_value)d item, it should contain no fewer than "
+"%(limit_value)d."
+msgid_plural ""
+"List contains %(show_value)d items, it should contain no fewer than "
+"%(limit_value)d."
+msgstr[0] ""
+"Tha %(show_value)d nì air an liosta ach cha bu chòir nas lugha na "
+"%(limit_value)d a bhith oirre."
+msgstr[1] ""
+"Tha %(show_value)d nì air an liosta ach cha bu chòir nas lugha na "
+"%(limit_value)d a bhith oirre."
+msgstr[2] ""
+"Tha %(show_value)d nithean air an liosta ach cha bu chòir nas lugha na "
+"%(limit_value)d a bhith oirre."
+msgstr[3] ""
+"Tha %(show_value)d nì air an liosta ach cha bu chòir nas lugha na "
+"%(limit_value)d a bhith oirre."
+
+#, python-format
+msgid "Some keys were missing: %(keys)s"
+msgstr "Bha cuid a dh’iuchraichean a dhìth: %(keys)s"
+
+#, python-format
+msgid "Some unknown keys were provided: %(keys)s"
+msgstr "Chaidh iuchraichean nach aithne dhuinn a shònrachadh: %(keys)s"
+
+#, python-format
+msgid ""
+"Ensure that this range is completely less than or equal to %(limit_value)s."
+msgstr ""
+"Dèan cinnteach gu bheil an rainse seo nas lugha na no co-ionnan ri "
+"%(limit_value)s air fad."
+
+#, python-format
+msgid ""
+"Ensure that this range is completely greater than or equal to "
+"%(limit_value)s."
+msgstr ""
+"Dèan cinnteach gu bheil an rainse seo nas motha na no co-ionnan ri "
+"%(limit_value)s air fad."