Initial commit. Basic models mostly done.

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

@@ -0,0 +1 @@
+default_app_config = 'django.contrib.postgres.apps.PostgresConfig'

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

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

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

@@ -0,0 +1,65 @@
+from django.contrib.postgres.fields import ArrayField, JSONField
+from django.db.models import Value
+from django.db.models.aggregates import Aggregate
+
+from .mixins import OrderableAggMixin
+
+__all__ = [
+    'ArrayAgg', 'BitAnd', 'BitOr', 'BoolAnd', 'BoolOr', 'JSONBAgg', 'StringAgg',
+]
+
+
+class ArrayAgg(OrderableAggMixin, Aggregate):
+    function = 'ARRAY_AGG'
+    template = '%(function)s(%(distinct)s%(expressions)s %(ordering)s)'
+    allow_distinct = True
+
+    @property
+    def output_field(self):
+        return ArrayField(self.source_expressions[0].output_field)
+
+    def convert_value(self, value, expression, connection):
+        if not value:
+            return []
+        return value
+
+
+class BitAnd(Aggregate):
+    function = 'BIT_AND'
+
+
+class BitOr(Aggregate):
+    function = 'BIT_OR'
+
+
+class BoolAnd(Aggregate):
+    function = 'BOOL_AND'
+
+
+class BoolOr(Aggregate):
+    function = 'BOOL_OR'
+
+
+class JSONBAgg(Aggregate):
+    function = 'JSONB_AGG'
+    output_field = JSONField()
+
+    def convert_value(self, value, expression, connection):
+        if not value:
+            return []
+        return value
+
+
+class StringAgg(OrderableAggMixin, Aggregate):
+    function = 'STRING_AGG'
+    template = '%(function)s(%(distinct)s%(expressions)s %(ordering)s)'
+    allow_distinct = True
+
+    def __init__(self, expression, delimiter, **extra):
+        delimiter_expr = Value(str(delimiter))
+        super().__init__(expression, delimiter_expr, **extra)
+
+    def convert_value(self, value, expression, connection):
+        if not value:
+            return ''
+        return value

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

@@ -0,0 +1,48 @@
+from django.db.models.expressions import F, OrderBy
+
+
+class OrderableAggMixin:
+
+    def __init__(self, *expressions, ordering=(), **extra):
+        if not isinstance(ordering, (list, tuple)):
+            ordering = [ordering]
+        ordering = ordering or []
+        # Transform minus sign prefixed strings into an OrderBy() expression.
+        ordering = (
+            (OrderBy(F(o[1:]), descending=True) if isinstance(o, str) and o[0] == '-' else o)
+            for o in ordering
+        )
+        super().__init__(*expressions, **extra)
+        self.ordering = self._parse_expressions(*ordering)
+
+    def resolve_expression(self, *args, **kwargs):
+        self.ordering = [expr.resolve_expression(*args, **kwargs) for expr in self.ordering]
+        return super().resolve_expression(*args, **kwargs)
+
+    def as_sql(self, compiler, connection):
+        if self.ordering:
+            ordering_params = []
+            ordering_expr_sql = []
+            for expr in self.ordering:
+                expr_sql, expr_params = expr.as_sql(compiler, connection)
+                ordering_expr_sql.append(expr_sql)
+                ordering_params.extend(expr_params)
+            sql, sql_params = super().as_sql(compiler, connection, ordering=(
+                'ORDER BY ' + ', '.join(ordering_expr_sql)
+            ))
+            return sql, sql_params + ordering_params
+        return super().as_sql(compiler, connection, ordering='')
+
+    def set_source_expressions(self, exprs):
+        # Extract the ordering expressions because ORDER BY clause is handled
+        # in a custom way.
+        self.ordering = exprs[self._get_ordering_expressions_index():]
+        return super().set_source_expressions(exprs[:self._get_ordering_expressions_index()])
+
+    def get_source_expressions(self):
+        return super().get_source_expressions() + self.ordering
+
+    def _get_ordering_expressions_index(self):
+        """Return the index at which the ordering expressions start."""
+        source_expressions = self.get_source_expressions()
+        return len(source_expressions) - len(self.ordering)

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

@@ -0,0 +1,66 @@
+from django.db.models import FloatField, IntegerField
+from django.db.models.aggregates import Aggregate
+
+__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):
+        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)
+
+
+class Corr(StatAggregate):
+    function = 'CORR'
+
+
+class CovarPop(StatAggregate):
+    def __init__(self, y, x, sample=False, filter=None):
+        self.function = 'COVAR_SAMP' if sample else 'COVAR_POP'
+        super().__init__(y, x, filter=filter)
+
+
+class RegrAvgX(StatAggregate):
+    function = 'REGR_AVGX'
+
+
+class RegrAvgY(StatAggregate):
+    function = 'REGR_AVGY'
+
+
+class RegrCount(StatAggregate):
+    function = 'REGR_COUNT'
+    output_field = IntegerField()
+
+    def convert_value(self, value, expression, connection):
+        return 0 if value is None else value
+
+
+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'

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

@@ -0,0 +1,66 @@
+from psycopg2.extras import (
+    DateRange, DateTimeRange, DateTimeTZRange, NumericRange,
+)
+
+from django.apps import AppConfig
+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, TextField
+from django.test.signals import setting_changed
+from django.utils.translation import gettext_lazy as _
+
+from .lookups import SearchLookup, TrigramSimilar, 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)
+        # 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():
+            if conn.vendor == 'postgresql':
+                conn.introspection.data_types_reverse.update({
+                    3802: 'django.contrib.postgres.fields.JSONField',
+                    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)
+        MigrationWriter.register_serializer(RANGE_TYPES, RangeSerializer)

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

@@ -0,0 +1,106 @@
+from django.db.backends.ddl_references import Statement, Table
+from django.db.models import F, Q
+from django.db.models.constraints import BaseConstraint
+from django.db.models.sql import Query
+
+__all__ = ['ExclusionConstraint']
+
+
+class ExclusionConstraint(BaseConstraint):
+    template = 'CONSTRAINT %(name)s EXCLUDE USING %(index_type)s (%(expressions)s)%(where)s'
+
+    def __init__(self, *, name, expressions, index_type=None, condition=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.'
+            )
+        self.expressions = expressions
+        self.index_type = index_type or 'GIST'
+        self.condition = condition
+        super().__init__(name=name)
+
+    def _get_expression_sql(self, compiler, connection, query):
+        expressions = []
+        for expression, operator in self.expressions:
+            if isinstance(expression, str):
+                expression = F(expression)
+            if isinstance(expression, F):
+                expression = expression.resolve_expression(query=query, simple_col=True)
+            else:
+                expression = expression.resolve_expression(query=query)
+            sql, params = expression.as_sql(compiler, connection)
+            expressions.append('%s WITH %s' % (sql % params, operator))
+        return expressions
+
+    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)
+        compiler = query.get_compiler(connection=schema_editor.connection)
+        expressions = self._get_expression_sql(compiler, schema_editor.connection, query)
+        condition = self._get_condition_sql(compiler, schema_editor, query)
+        return self.template % {
+            'name': schema_editor.quote_name(self.name),
+            'index_type': self.index_type,
+            'expressions': ', '.join(expressions),
+            'where': ' WHERE (%s)' % condition if condition else '',
+        }
+
+    def create_sql(self, model, 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 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
+        return path, args, kwargs
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, self.__class__) and
+            self.name == other.name and
+            self.index_type == other.index_type and
+            self.expressions == other.expressions and
+            self.condition == other.condition
+        )
+
+    def __repr__(self):
+        return '<%s: index_type=%s, expressions=%s%s>' % (
+            self.__class__.__qualname__,
+            self.index_type,
+            self.expressions,
+            '' if self.condition is None else ', condition=%s' % self.condition,
+        )

venv/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

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

@@ -0,0 +1,300 @@
+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, IntegerField, Transform
+from django.db.models.lookups import Exact, In
+from django.utils.translation import gettext_lazy as _
+
+from ..utils import prefix_validation_error
+from .mixins import CheckFieldDefaultMixin
+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
+
+    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 ArrayCastRHSMixin:
+    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(ArrayCastRHSMixin, lookups.DataContains):
+    pass
+
+
+@ArrayField.register_lookup
+class ArrayContainedBy(ArrayCastRHSMixin, lookups.ContainedBy):
+    pass
+
+
+@ArrayField.register_lookup
+class ArrayExact(ArrayCastRHSMixin, Exact):
+    pass
+
+
+@ArrayField.register_lookup
+class ArrayOverlap(ArrayCastRHSMixin, 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)

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

@@ -0,0 +1,24 @@
+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

venv/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.utils.translation import gettext_lazy as _
+
+from .mixins import CheckFieldDefaultMixin
+
+__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())

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

@@ -0,0 +1,186 @@
+import json
+
+from psycopg2.extras import Json
+
+from django.contrib.postgres import forms, lookups
+from django.core import exceptions
+from django.db.models import (
+    Field, TextField, Transform, lookups as builtin_lookups,
+)
+from django.utils.translation import gettext_lazy as _
+
+from .mixins import CheckFieldDefaultMixin
+
+__all__ = ['JSONField']
+
+
+class JsonAdapter(Json):
+    """
+    Customized psycopg2.extras.Json to allow for a custom encoder.
+    """
+    def __init__(self, adapted, dumps=None, encoder=None):
+        self.encoder = encoder
+        super().__init__(adapted, dumps=dumps)
+
+    def dumps(self, obj):
+        options = {'cls': self.encoder} if self.encoder else {}
+        return json.dumps(obj, **options)
+
+
+class JSONField(CheckFieldDefaultMixin, Field):
+    empty_strings_allowed = False
+    description = _('A JSON object')
+    default_error_messages = {
+        'invalid': _("Value must be valid JSON."),
+    }
+    _default_hint = ('dict', '{}')
+
+    def __init__(self, verbose_name=None, name=None, encoder=None, **kwargs):
+        if encoder and not callable(encoder):
+            raise ValueError("The encoder parameter must be a callable object.")
+        self.encoder = encoder
+        super().__init__(verbose_name, name, **kwargs)
+
+    def db_type(self, connection):
+        return 'jsonb'
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.encoder is not None:
+            kwargs['encoder'] = self.encoder
+        return name, path, args, kwargs
+
+    def get_transform(self, name):
+        transform = super().get_transform(name)
+        if transform:
+            return transform
+        return KeyTransformFactory(name)
+
+    def get_prep_value(self, value):
+        if value is not None:
+            return JsonAdapter(value, encoder=self.encoder)
+        return value
+
+    def validate(self, value, model_instance):
+        super().validate(value, model_instance)
+        options = {'cls': self.encoder} if self.encoder else {}
+        try:
+            json.dumps(value, **options)
+        except TypeError:
+            raise exceptions.ValidationError(
+                self.error_messages['invalid'],
+                code='invalid',
+                params={'value': value},
+            )
+
+    def value_to_string(self, obj):
+        return self.value_from_object(obj)
+
+    def formfield(self, **kwargs):
+        return super().formfield(**{
+            'form_class': forms.JSONField,
+            **kwargs,
+        })
+
+
+JSONField.register_lookup(lookups.DataContains)
+JSONField.register_lookup(lookups.ContainedBy)
+JSONField.register_lookup(lookups.HasKey)
+JSONField.register_lookup(lookups.HasKeys)
+JSONField.register_lookup(lookups.HasAnyKeys)
+JSONField.register_lookup(lookups.JSONExact)
+
+
+class KeyTransform(Transform):
+    operator = '->'
+    nested_operator = '#>'
+
+    def __init__(self, key_name, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.key_name = key_name
+
+    def as_sql(self, compiler, connection):
+        key_transforms = [self.key_name]
+        previous = self.lhs
+        while isinstance(previous, KeyTransform):
+            key_transforms.insert(0, previous.key_name)
+            previous = previous.lhs
+        lhs, params = compiler.compile(previous)
+        if len(key_transforms) > 1:
+            return '(%s %s %%s)' % (lhs, self.nested_operator), params + [key_transforms]
+        try:
+            lookup = int(self.key_name)
+        except ValueError:
+            lookup = self.key_name
+        return '(%s %s %%s)' % (lhs, self.operator), tuple(params) + (lookup,)
+
+
+class KeyTextTransform(KeyTransform):
+    operator = '->>'
+    nested_operator = '#>>'
+    output_field = TextField()
+
+
+class KeyTransformTextLookupMixin:
+    """
+    Mixin for combining with a lookup expecting a text lhs from a JSONField
+    key lookup. Make use of the ->> operator instead of casting key values to
+    text and performing the lookup on the resulting representation.
+    """
+    def __init__(self, key_transform, *args, **kwargs):
+        assert isinstance(key_transform, KeyTransform)
+        key_text_transform = KeyTextTransform(
+            key_transform.key_name, *key_transform.source_expressions, **key_transform.extra
+        )
+        super().__init__(key_text_transform, *args, **kwargs)
+
+
+class KeyTransformIExact(KeyTransformTextLookupMixin, builtin_lookups.IExact):
+    pass
+
+
+class KeyTransformIContains(KeyTransformTextLookupMixin, builtin_lookups.IContains):
+    pass
+
+
+class KeyTransformStartsWith(KeyTransformTextLookupMixin, builtin_lookups.StartsWith):
+    pass
+
+
+class KeyTransformIStartsWith(KeyTransformTextLookupMixin, builtin_lookups.IStartsWith):
+    pass
+
+
+class KeyTransformEndsWith(KeyTransformTextLookupMixin, builtin_lookups.EndsWith):
+    pass
+
+
+class KeyTransformIEndsWith(KeyTransformTextLookupMixin, builtin_lookups.IEndsWith):
+    pass
+
+
+class KeyTransformRegex(KeyTransformTextLookupMixin, builtin_lookups.Regex):
+    pass
+
+
+class KeyTransformIRegex(KeyTransformTextLookupMixin, builtin_lookups.IRegex):
+    pass
+
+
+KeyTransform.register_lookup(KeyTransformIExact)
+KeyTransform.register_lookup(KeyTransformIContains)
+KeyTransform.register_lookup(KeyTransformStartsWith)
+KeyTransform.register_lookup(KeyTransformIStartsWith)
+KeyTransform.register_lookup(KeyTransformEndsWith)
+KeyTransform.register_lookup(KeyTransformIEndsWith)
+KeyTransform.register_lookup(KeyTransformRegex)
+KeyTransform.register_lookup(KeyTransformIRegex)
+
+
+class KeyTransformFactory:
+
+    def __init__(self, key_name):
+        self.key_name = key_name
+
+    def __call__(self, *args, **kwargs):
+        return KeyTransform(self.key_name, *args, **kwargs)

venv/lib/python3.8/site-packages/django/contrib/postgres/fields/mixins.py

@@ -0,0 +1,29 @@
+from django.core import checks
+
+
+class CheckFieldDefaultMixin:
+    _default_hint = ('<valid default>', '<invalid default>')
+
+    def _check_default(self):
+        if self.has_default() and self.default is not None and not callable(self.default):
+            return [
+                checks.Warning(
+                    "%s default should be a callable instead of an instance so "
+                    "that it's not shared between all field instances." % (
+                        self.__class__.__name__,
+                    ),
+                    hint=(
+                        'Use a callable instead, e.g., use `%s` instead of '
+                        '`%s`.' % self._default_hint
+                    ),
+                    obj=self,
+                    id='postgres.E003',
+                )
+            ]
+        else:
+            return []
+
+    def check(self, **kwargs):
+        errors = super().check(**kwargs)
+        errors.extend(self._check_default())
+        return errors

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

@@ -0,0 +1,299 @@
+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 .utils import AttributeSetter
+
+__all__ = [
+    'RangeField', 'IntegerRangeField', 'BigIntegerRangeField',
+    'DecimalRangeField', 'DateTimeRangeField', 'DateRangeField',
+    'FloatRangeField',
+    '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):
+        # 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
+
+    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)
+
+
+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(RangeField):
+    base_field = models.DecimalField
+    range_type = NumericRange
+    form_field = forms.DecimalRangeField
+
+    def db_type(self, connection):
+        return 'numrange'
+
+
+class FloatRangeField(RangeField):
+    system_check_deprecated_details = {
+        'msg': (
+            'FloatRangeField is deprecated and will be removed in Django 3.1.'
+        ),
+        'hint': 'Use DecimalRangeField instead.',
+        'id': 'fields.W902',
+    }
+    base_field = models.FloatField
+    range_type = NumericRange
+    form_field = forms.FloatRangeField
+
+    def db_type(self, connection):
+        return 'numrange'
+
+
+class DateTimeRangeField(RangeField):
+    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(lookups.PostgresSimpleLookup):
+    """
+    Lookup for Date/DateTimeRange containment to cast the rhs to the correct
+    type.
+    """
+    lookup_name = 'contains'
+    operator = RangeOperators.CONTAINS
+
+    def process_rhs(self, compiler, connection):
+        # Transform rhs value for db lookup.
+        if isinstance(self.rhs, datetime.date):
+            output_field = models.DateTimeField() if isinstance(self.rhs, datetime.datetime) else models.DateField()
+            value = models.Value(self.rhs, output_field=output_field)
+            self.rhs = value.resolve_expression(compiler.query)
+        return super().process_rhs(compiler, connection)
+
+    def as_sql(self, compiler, connection):
+        sql, params = super().as_sql(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(lookups.PostgresSimpleLookup):
+    lookup_name = 'contained_by'
+    type_mapping = {
+        'integer': 'int4range',
+        'bigint': 'int8range',
+        'double precision': 'numrange',
+        'date': 'daterange',
+        'timestamp with time zone': 'tstzrange',
+    }
+    operator = RangeOperators.CONTAINED_BY
+
+    def process_rhs(self, compiler, connection):
+        rhs, rhs_params = super().process_rhs(compiler, connection)
+        cast_type = self.type_mapping[self.lhs.output_field.db_type(connection)]
+        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
+        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.BigIntegerField.register_lookup(RangeContainedBy)
+models.FloatField.register_lookup(RangeContainedBy)
+
+
+@RangeField.register_lookup
+class FullyLessThan(lookups.PostgresSimpleLookup):
+    lookup_name = 'fully_lt'
+    operator = RangeOperators.FULLY_LT
+
+
+@RangeField.register_lookup
+class FullGreaterThan(lookups.PostgresSimpleLookup):
+    lookup_name = 'fully_gt'
+    operator = RangeOperators.FULLY_GT
+
+
+@RangeField.register_lookup
+class NotLessThan(lookups.PostgresSimpleLookup):
+    lookup_name = 'not_lt'
+    operator = RangeOperators.NOT_LT
+
+
+@RangeField.register_lookup
+class NotGreaterThan(lookups.PostgresSimpleLookup):
+    lookup_name = 'not_gt'
+    operator = RangeOperators.NOT_GT
+
+
+@RangeField.register_lookup
+class AdjacentToLookup(lookups.PostgresSimpleLookup):
+    lookup_name = 'adjacent_to'
+    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()

venv/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)

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

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

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

@@ -0,0 +1,218 @@
+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 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)
+        if self.remove_trailing_nulls:
+            null_index = None
+            for i, value in reversed(list(enumerate(cleaned_data))):
+                if value in self.base_field.empty_values:
+                    null_index = i
+                else:
+                    break
+            if null_index is not None:
+                cleaned_data = cleaned_data[:null_index]
+                errors = errors[:null_index]
+        errors = list(filter(None, errors))
+        if errors:
+            raise ValidationError(list(chain.from_iterable(errors)))
+        return cleaned_data

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

@@ -0,0 +1,58 @@
+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)

venv/lib/python3.8/site-packages/django/contrib/postgres/forms/jsonb.py

@@ -0,0 +1,62 @@
+import json
+
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+__all__ = ['JSONField']
+
+
+class InvalidJSONInput(str):
+    pass
+
+
+class JSONString(str):
+    pass
+
+
+class JSONField(forms.CharField):
+    default_error_messages = {
+        'invalid': _('“%(value)s” value must be valid JSON.'),
+    }
+    widget = forms.Textarea
+
+    def to_python(self, value):
+        if self.disabled:
+            return value
+        if value in self.empty_values:
+            return None
+        elif isinstance(value, (list, dict, int, float, JSONString)):
+            return value
+        try:
+            converted = json.loads(value)
+        except json.JSONDecodeError:
+            raise forms.ValidationError(
+                self.error_messages['invalid'],
+                code='invalid',
+                params={'value': value},
+            )
+        if isinstance(converted, str):
+            return JSONString(converted)
+        else:
+            return converted
+
+    def bound_data(self, data, initial):
+        if self.disabled:
+            return initial
+        try:
+            return json.loads(data)
+        except json.JSONDecodeError:
+            return InvalidJSONInput(data)
+
+    def prepare_value(self, value):
+        if isinstance(value, InvalidJSONInput):
+            return value
+        return json.dumps(value)
+
+    def has_changed(self, initial, data):
+        if super().has_changed(initial, data):
+            return True
+        # For purposes of seeing whether something has changed, True isn't the
+        # same as 1 and the order of keys doesn't matter.
+        data = self.to_python(data)
+        return json.dumps(initial, sort_keys=True) != json.dumps(data, sort_keys=True)

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

@@ -0,0 +1,117 @@
+import warnings
+
+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.deprecation import RemovedInDjango31Warning
+from django.utils.translation import gettext_lazy as _
+
+__all__ = [
+    'BaseRangeField', 'IntegerRangeField', 'DecimalRangeField',
+    'DateTimeRangeField', 'DateRangeField', 'FloatRangeField',
+    '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)
+        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)
+        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 FloatRangeField(DecimalRangeField):
+    base_field = forms.FloatField
+
+    def __init__(self, **kwargs):
+        warnings.warn(
+            'FloatRangeField is deprecated in favor of DecimalRangeField.',
+            RemovedInDjango31Warning, stacklevel=2,
+        )
+        super().__init__(**kwargs)
+
+
+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

venv/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()

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

@@ -0,0 +1,177 @@
+from django.db.models import Index
+from django.db.utils import NotSupportedError
+from django.utils.functional import cached_property
+
+__all__ = [
+    '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' % 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 BrinIndex(PostgresIndex):
+    suffix = 'brin'
+
+    def __init__(self, *, 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__(**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 check_supported(self, schema_editor):
+        if self.autosummarize and not schema_editor.connection.features.has_brin_autosummarize:
+            raise NotSupportedError('BRIN option autosummarize requires PostgreSQL 10+.')
+
+    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, *, fillfactor=None, **kwargs):
+        self.fillfactor = fillfactor
+        super().__init__(**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, *, fastupdate=None, gin_pending_list_limit=None, **kwargs):
+        self.fastupdate = fastupdate
+        self.gin_pending_list_limit = gin_pending_list_limit
+        super().__init__(**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, *, buffering=None, fillfactor=None, **kwargs):
+        self.buffering = buffering
+        self.fillfactor = fillfactor
+        super().__init__(**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
+
+
+class HashIndex(PostgresIndex):
+    suffix = 'hash'
+
+    def __init__(self, *, fillfactor=None, **kwargs):
+        self.fillfactor = fillfactor
+        super().__init__(**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, *, fillfactor=None, **kwargs):
+        self.fillfactor = fillfactor
+        super().__init__(**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

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

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

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

@@ -0,0 +1,114 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# F Wolff <friedel@translate.org.za>, 2019
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2019-01-04 18:56+0000\n"
+"Last-Translator: F Wolff <friedel@translate.org.za>\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 van “%(key)s” is nie 'n string of nul nie."
+
+msgid "A JSON object"
+msgstr "’n JSON-objek"
+
+msgid "Value must be valid JSON."
+msgstr "Die waarde moet geldige JSON wees."
+
+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."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "Die waarde “%(value)s” moet geldige JSON 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."

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

@@ -0,0 +1,140 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Bashar Al-Abdulhadi, 2015-2017
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2017-01-19 16:49+0100\n"
+"PO-Revision-Date: 2017-09-21 22:44+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\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 ""
+
+#, python-format
+msgid "The value of \"%(key)s\" is not a string or null."
+msgstr ""
+
+msgid "A JSON object"
+msgstr "كائن JSON"
+
+msgid "Value must be valid JSON."
+msgstr "يجب أن تكون قيمة JSON صالحة."
+
+msgid "Could not load JSON data."
+msgstr "لا يمكن عرض بيانات JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "المُدخل يجب أن يكون بصيغة بصيغة قاموس JSON."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "القيمة '%(value)s' يجب أن تكون قيمة 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."

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

@@ -0,0 +1,112 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2020-01-12 07:22+0000\n"
+"Last-Translator: Emin Mastizada <emin@linux.com>\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 "A JSON object"
+msgstr "JSON obyekt"
+
+msgid "Value must be valid JSON."
+msgstr "Dəyər düzgün JSON olmalıdır."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "“%(value)s” dəyəri düzgün JSON 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."

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

@@ -0,0 +1,132 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2019-10-16 18:19+0000\n"
+"Last-Translator: znotdead <zhirafchik@gmail.com>\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 "A JSON object"
+msgstr "JSON аб’ект"
+
+msgid "Value must be valid JSON."
+msgstr "Значэнне павінна быць сапраўдным JSON."
+
+msgid "Could not load JSON data."
+msgstr "Не атрымалася загрузіць дадзеныя JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Значэнне павінна быць JSON слоўнікам. "
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "“%(value)s” значэнне павінна быць сапраўдным 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."

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

@@ -0,0 +1,119 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Todor Lubenov <tgl.sysdev@gmail.com>, 2015
+# Venelin Stoykov <vkstoykov@gmail.com>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2017-01-19 16:49+0100\n"
+"PO-Revision-Date: 2017-09-21 22:44+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\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 ""
+
+#, python-format
+msgid "The value of \"%(key)s\" is not a string or null."
+msgstr ""
+
+msgid "A JSON object"
+msgstr "JSON обект"
+
+msgid "Value must be valid JSON."
+msgstr "Стойността трябва да е валиден JSON"
+
+msgid "Could not load JSON data."
+msgstr "Не можа да зареди JSON данни ."
+
+msgid "Input must be a JSON dictionary."
+msgstr ""
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "'%(value)s' стойност трябва да е 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."

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

@@ -0,0 +1,121 @@
+# 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
+# Roger Pons <rogerpons@gmail.com>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2019-01-29 07:53+0000\n"
+"Last-Translator: Gil Obradors Via <gil.obradors@gmail.com>\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 "A JSON object"
+msgstr "Un objecte JSON"
+
+msgid "Value must be valid JSON."
+msgstr "El valor ha de ser JSON vàlid."
+
+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"
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "El valor '%(value)s' ha de ser JSON vàlid."
+
+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."

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

@@ -0,0 +1,129 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2019-09-19 08:58+0000\n"
+"Last-Translator: Vláďa Macek <macek@sandbox.cz>\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 "A JSON object"
+msgstr "Objekt typu JSON"
+
+msgid "Value must be valid JSON."
+msgstr "Musí být v platném formátu JSON."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "Hodnota \"%(value)s\" musí být v platném 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."

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

@@ -0,0 +1,120 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Erik Wognsen <r4mses@gmail.com>, 2015-2019
+# valberg <valberg@orn.li>, 2015
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2019-09-17 18:02+0000\n"
+"Last-Translator: Erik 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 "A JSON object"
+msgstr "Et JSON-objekt."
+
+msgid "Value must be valid JSON."
+msgstr "Værdien skal være gyldig JSON."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "“%(value)s”-værdien skal være gyldig JSON."
+
+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."

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

@@ -0,0 +1,117 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2020-01-17 23:01+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\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 "A JSON object"
+msgstr "Ein JSON-Objekt"
+
+msgid "Value must be valid JSON."
+msgstr "Wert muss gültiges JSON sein."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "Wert „%(value)s“ muss gültiges JSON 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."

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

@@ -0,0 +1,131 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Michael Wolf <milupo@sorbzilla.de>, 2016-2018
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2018-05-26 10:31+0000\n"
+"Last-Translator: Michael Wolf <milupo@sorbzilla.de>\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 "A JSON object"
+msgstr "JSON-objekt"
+
+msgid "Value must be valid JSON."
+msgstr "Gódnota musy płaśiwy JSON byś."
+
+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ś."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "Gódnota '%(value)s' musy płaśiwy JSON 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."

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

@@ -0,0 +1,120 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# 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: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2018-09-22 10:12+0000\n"
+"Last-Translator: Nick Mavrakis <mavrakis.n@gmail.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 "A JSON object"
+msgstr "Ένα αντικείμενο JSON"
+
+msgid "Value must be valid JSON."
+msgstr "Η τιμή πρέπει να είναι έγκυρο JSON."
+
+msgid "Could not load JSON data."
+msgstr "Αδύνατη η φόρτωση των δεδομένων JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr "Το input πρέπει να είναι ένα έγκυρο JSON dictionary."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "Η τιμή '%(value)s' πρέπει να είναι έγκυρο JSON."
+
+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."

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

@@ -0,0 +1,128 @@
+# 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: 2019-09-08 17:27+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:16
+msgid "Map of strings to strings/nulls"
+msgstr ""
+
+#: contrib/postgres/fields/hstore.py:18
+#, python-format
+msgid "The value of “%(key)s” is not a string or null."
+msgstr ""
+
+#: contrib/postgres/fields/jsonb.py:32
+msgid "A JSON object"
+msgstr ""
+
+#: contrib/postgres/fields/jsonb.py:34
+msgid "Value must be valid JSON."
+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/jsonb.py:19
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:19
+msgid "Enter two valid values."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:20
+msgid "The start of the range must not exceed the end of the range."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:67
+msgid "Enter two whole numbers."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:73
+msgid "Enter two numbers."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:90
+msgid "Enter two valid date/times."
+msgstr ""
+
+#: contrib/postgres/forms/ranges.py:96
+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 ""

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

@@ -0,0 +1,119 @@
+# 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: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2019-01-18 12:47+0000\n"
+"Last-Translator: Baptiste Darthenay <baptiste+transifex@darthenay.fr>\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 "La valoro de \"%(key)s\" ne estas signoĉeno nek nulvaloro."
+
+msgid "A JSON object"
+msgstr "JSON objekto"
+
+msgid "Value must be valid JSON."
+msgstr "Valoro devas esti valida JSON."
+
+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."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "'%(value)s' devas esti valida JSON."
+
+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."

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

@@ -0,0 +1,123 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Antoni Aloy <aaloy@apsl.net>, 2015,2017
+# Ernesto Avilés Vázquez <whippiii@gmail.com>, 2015
+# Ignacio José Lizarán Rus <ilizaran@gmail.com>, 2019
+# 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: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2019-02-19 08:46+0000\n"
+"Last-Translator: Ignacio José Lizarán Rus <ilizaran@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 ni una cadena ni un nulo"
+
+msgid "A JSON object"
+msgstr "Un objeto JSON"
+
+msgid "Value must be valid JSON."
+msgstr "El valor debe ser un JSON válido."
+
+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"
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "El valor \"%(value)s\" debe ser un JSON válido."
+
+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."

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

@@ -0,0 +1,118 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2019-10-01 10:28+0000\n"
+"Last-Translator: Ramiro Morales\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 "A JSON object"
+msgstr "Un objeto JSON"
+
+msgid "Value must be valid JSON."
+msgstr "El valor debe ser JSON válido."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "El valor de“%(value)s” debe ser JSON válido."
+
+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."

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

@@ -0,0 +1,122 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Antoni Aloy <aaloy@apsl.net>, 2015
+# Ernesto Avilés Vázquez <whippiii@gmail.com>, 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: 2017-01-19 16:49+0100\n"
+"PO-Revision-Date: 2017-09-21 22:44+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\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 "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 ""
+
+#, python-format
+msgid "The value of \"%(key)s\" is not a string or null."
+msgstr ""
+
+msgid "A JSON object"
+msgstr "Un objeto JSON"
+
+msgid "Value must be valid JSON."
+msgstr "El valor debe ser un JSON válido."
+
+msgid "Could not load JSON data."
+msgstr "No se pududieron cargar los datos JSON."
+
+msgid "Input must be a JSON dictionary."
+msgstr ""
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "El valor \"%(value)s\" debe ser un JSON válido."
+
+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."

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

@@ -0,0 +1,108 @@
+# 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: 2017-01-19 16:49+0100\n"
+"PO-Revision-Date: 2017-09-21 22:44+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\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 "A JSON object"
+msgstr "Un objeto JSON"
+
+msgid "Value must be valid JSON."
+msgstr "El valor debe ser JSON válido"
+
+msgid "Could not load JSON data."
+msgstr ""
+
+msgid "Input must be a JSON dictionary."
+msgstr ""
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+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 ""

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

@@ -0,0 +1,121 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2019-12-28 02:40+0000\n"
+"Last-Translator: Ragnar Rebase <rrebase@gmail.com>\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 "A JSON object"
+msgstr "JSON objekt"
+
+msgid "Value must be valid JSON."
+msgstr "Väärtus peab olema korrektne JSON."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "“%(value)s” väärtus peab olema korrektne JSON."
+
+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."

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

@@ -0,0 +1,118 @@
+# 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
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2018-08-24 07:33+0000\n"
+"Last-Translator: Eneko Illarramendi <eneko@illarra.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 "A JSON object"
+msgstr "JSON objetu bat"
+
+msgid "Value must be valid JSON."
+msgstr "Balioa ez da baleko JSON bat."
+
+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."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "'%(value)s' balioa ez da baleko JSON bat."
+
+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."

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

@@ -0,0 +1,117 @@
+# 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
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2018-05-17 11:49+0200\n"
+"PO-Revision-Date: 2018-06-23 23:11+0000\n"
+"Last-Translator: MJafar Mashhadi <raindigital2007@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\" باید رشته یا هیچمقدار باشد."
+
+msgid "A JSON object"
+msgstr "یک شیء JSON"
+
+msgid "Value must be valid JSON."
+msgstr "مقدار باید JSON معتبر باشد."
+
+msgid "Could not load JSON data."
+msgstr "امکان بارگزاری  داده های JSON  نیست."
+
+msgid "Input must be a JSON dictionary."
+msgstr "مقدار ورودی باید یک دیکشنری JSON باشد."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "مقدار  %(value)s باید 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 است."

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

@@ -0,0 +1,120 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# Aarni Koskela, 2015,2017
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2017-01-19 16:49+0100\n"
+"PO-Revision-Date: 2017-09-21 22:44+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 "A JSON object"
+msgstr "JSON-tietue"
+
+msgid "Value must be valid JSON."
+msgstr "Arvon pitää olla kelvollista JSONia."
+
+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."
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr "%(value)s-arvo tulee olla kelvollista JSONia."
+
+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."

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

@@ -0,0 +1,119 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2019-09-18 15:55+0000\n"
+"Last-Translator: Claude Paroz <claude@2xlibre.net>\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 "A JSON object"
+msgstr "Un objet JSON"
+
+msgid "Value must be valid JSON."
+msgstr "La valeur doit être de la syntaxe JSON valable."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "La valeur « %(value)s » doit être de la syntaxe JSON valable."
+
+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."

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

@@ -0,0 +1,135 @@
+# 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: 2019-09-08 17:27+0200\n"
+"PO-Revision-Date: 2019-12-13 12:32+0000\n"
+"Last-Translator: GunChleoc\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 "A JSON object"
+msgstr "Oibjeact JSON"
+
+msgid "Value must be valid JSON."
+msgstr "Feumaidh an luach a bhith ’na JSON dligheach."
+
+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."
+
+#, python-format
+msgid "“%(value)s” value must be valid JSON."
+msgstr "Feumaidh luach “%(value)s” a bhith ’na JSON dligheach."
+
+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."

venv/lib/python3.8/site-packages/django/contrib/postgres/locale/gl/LC_MESSAGES/django.po

@@ -0,0 +1,108 @@
+# This file is distributed under the same license as the Django package.
+#
+# Translators:
+# fasouto <fsoutomoure@gmail.com>, 2017
+msgid ""
+msgstr ""
+"Project-Id-Version: django\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2017-01-19 16:49+0100\n"
+"PO-Revision-Date: 2017-09-21 22:44+0000\n"
+"Last-Translator: fasouto <fsoutomoure@gmail.com>\n"
+"Language-Team: Galician (http://www.transifex.com/django/django/language/"
+"gl/)\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Language: gl\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+msgid "PostgreSQL extensions"
+msgstr ""
+
+#, 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 "A JSON object"
+msgstr "Un obxecto JSON"
+
+msgid "Value must be valid JSON."
+msgstr "O valor debe ser JSON válido."
+
+msgid "Could not load JSON data."
+msgstr ""
+
+msgid "Input must be a JSON dictionary."
+msgstr ""
+
+#, python-format
+msgid "'%(value)s' value must be valid JSON."
+msgstr ""
+
+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 "Insira dous números."
+
+msgid "Enter two valid date/times."
+msgstr ""
+
+msgid "Enter two valid dates."
+msgstr "Insira dúas datas 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 ""