{"instance_id": "django__django-11603", "model_name_or_path": "cain-anthropic-e124", "model_patch": "diff --git a/django/db/models/aggregates.py b/django/db/models/aggregates.py\nindex da4ff928aa..3effaa7533 100644\n--- a/django/db/models/aggregates.py\n+++ b/django/db/models/aggregates.py\n@@ -99,6 +99,7 @@ class Aggregate(Func):\n class Avg(FixDurationInputMixin, NumericOutputFieldMixin, Aggregate):\n     function = 'AVG'\n     name = 'Avg'\n+    allow_distinct = True\n \n \n class Count(Aggregate):\n@@ -121,11 +122,13 @@ class Count(Aggregate):\n class Max(Aggregate):\n     function = 'MAX'\n     name = 'Max'\n+    allow_distinct = True\n \n \n class Min(Aggregate):\n     function = 'MIN'\n     name = 'Min'\n+    allow_distinct = True\n \n \n class StdDev(NumericOutputFieldMixin, Aggregate):\n@@ -142,6 +145,7 @@ class StdDev(NumericOutputFieldMixin, Aggregate):\n class Sum(FixDurationInputMixin, Aggregate):\n     function = 'SUM'\n     name = 'Sum'\n+    allow_distinct = True\n \n \n class Variance(NumericOutputFieldMixin, Aggregate):\n", "model": "claude-sonnet-5-5", "steps": 6, "finished": true, "patch_lines": 34, "candidates": [{"compile_ok": 0, "loc_hits": 0, "files": 1, "diff_lines": 34, "steps": 6}], "ms": 16897}
{"instance_id": "django__django-11728", "model_name_or_path": "cain-anthropic-e124", "model_patch": "diff --git a/django/contrib/admindocs/utils.py b/django/contrib/admindocs/utils.py\nindex 1ce4594501..7d2f395073 100644\n--- a/django/contrib/admindocs/utils.py\n+++ b/django/contrib/admindocs/utils.py\n@@ -167,12 +167,6 @@ def replace_named_groups(pattern):\n         # Handle nested parentheses, e.g. '^(?P<a>(x|y))/b'.\n         unmatched_open_brackets, prev_char = 1, None\n         for idx, val in enumerate(pattern[end:]):\n-            # If brackets are balanced, the end of the string for the current\n-            # named capture group pattern has been reached.\n-            if unmatched_open_brackets == 0:\n-                group_pattern_and_name.append((pattern[start:end + idx], group_name))\n-                break\n-\n             # Check for unescaped `(` and `)`. They mark the start and end of a\n             # nested group.\n             if val == '(' and prev_char != '\\\\':\n@@ -181,6 +175,12 @@ def replace_named_groups(pattern):\n                 unmatched_open_brackets -= 1\n             prev_char = val\n \n+            # If brackets are balanced, the end of the string for the current\n+            # named capture group pattern has been reached.\n+            if unmatched_open_brackets == 0:\n+                group_pattern_and_name.append((pattern[start:end + idx + 1], group_name))\n+                break\n+\n     # Replace the string for named capture groups with their group names.\n     for group_pattern, group_name in group_pattern_and_name:\n         pattern = pattern.replace(group_pattern, group_name)\n@@ -201,10 +201,6 @@ def replace_unnamed_groups(pattern):\n         # Handle nested parentheses, e.g. '^b/((x|y)\\w+)$'.\n         unmatched_open_brackets, prev_char = 1, None\n         for idx, val in enumerate(pattern[start + 1:]):\n-            if unmatched_open_brackets == 0:\n-                group_indices.append((start, start + 1 + idx))\n-                break\n-\n             # Check for unescaped `(` and `)`. They mark the start and end of\n             # a nested group.\n             if val == '(' and prev_char != '\\\\':\n@@ -213,6 +209,10 @@ def replace_unnamed_groups(pattern):\n                 unmatched_open_brackets -= 1\n             prev_char = val\n \n+            if unmatched_open_brackets == 0:\n+                group_indices.append((start, start + 2 + idx))\n+                break\n+\n     # Remove unnamed group matches inside other unnamed capture groups.\n     group_start_end_indices = []\n     prev_end = None\n", "model": "claude-sonnet-5-5", "steps": 6, "finished": true, "patch_lines": 52, "candidates": [{"compile_ok": 0, "loc_hits": 1, "files": 1, "diff_lines": 52, "steps": 6}], "ms": 26877}
{"instance_id": "django__django-11734", "model_name_or_path": "cain-70b-e124", "model_patch": "diff --git a/tests/queries/test_qs_combinators.py b/tests/queries/test_qs_combinators.py\nindex 668d5e6ad6..7abbfba773 100644\n--- a/tests/queries/test_qs_combinators.py\n+++ b/tests/queries/test_qs_combinators.py\n@@ -1,287 +1,27 @@\n-from django.db import connection\n-from django.db.models import Exists, F, IntegerField, OuterRef, Value\n-from django.db.utils import DatabaseError, NotSupportedError\n-from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature\n-\n-from .models import Number, ReservedName\n-\n-\n-@skipUnlessDBFeature('supports_select_union')\n-class QuerySetSetOperationTests(TestCase):\n-    @classmethod\n-    def setUpTestData(cls):\n-        Number.objects.bulk_create(Number(num=i, other_num=10 - i) for i in range(10))\n-\n-    def number_transform(self, value):\n-        return value.num\n-\n-    def assertNumbersEqual(self, queryset, expected_numbers, ordered=True):\n-        self.assertQuerysetEqual(queryset, expected_numbers, self.number_transform, ordered)\n-\n-    def test_simple_union(self):\n-        qs1 = Number.objects.filter(num__lte=1)\n-        qs2 = Number.objects.filter(num__gte=8)\n-        qs3 = Number.objects.filter(num=5)\n-        self.assertNumbersEqual(qs1.union(qs2, qs3), [0, 1, 5, 8, 9], ordered=False)\n-\n-    @skipUnlessDBFeature('supports_select_intersection')\n-    def test_simple_intersection(self):\n-        qs1 = Number.objects.filter(num__lte=5)\n-        qs2 = Number.objects.filter(num__gte=5)\n-        qs3 = Number.objects.filter(num__gte=4, num__lte=6)\n-        self.assertNumbersEqual(qs1.intersection(qs2, qs3), [5], ordered=False)\n-\n-    @skipUnlessDBFeature('supports_select_intersection')\n-    def test_intersection_with_values(self):\n-        ReservedName.objects.create(name='a', order=2)\n-        qs1 = ReservedName.objects.all()\n-        reserved_name = qs1.intersection(qs1).values('name', 'order', 'id').get()\n-        self.assertEqual(reserved_name['name'], 'a')\n-        self.assertEqual(reserved_name['order'], 2)\n-        reserved_name = qs1.intersection(qs1).values_list('name', 'order', 'id').get()\n-        self.assertEqual(reserved_name[:2], ('a', 2))\n-\n-    @skipUnlessDBFeature('supports_select_difference')\n-    def test_simple_difference(self):\n-        qs1 = Number.objects.filter(num__lte=5)\n-        qs2 = Number.objects.filter(num__lte=4)\n-        self.assertNumbersEqual(qs1.difference(qs2), [5], ordered=False)\n-\n-    def test_union_distinct(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.all()\n-        self.assertEqual(len(list(qs1.union(qs2, all=True))), 20)\n-        self.assertEqual(len(list(qs1.union(qs2))), 10)\n-\n-    @skipUnlessDBFeature('supports_select_intersection')\n-    def test_intersection_with_empty_qs(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.none()\n-        qs3 = Number.objects.filter(pk__in=[])\n-        self.assertEqual(len(qs1.intersection(qs2)), 0)\n-        self.assertEqual(len(qs1.intersection(qs3)), 0)\n-        self.assertEqual(len(qs2.intersection(qs1)), 0)\n-        self.assertEqual(len(qs3.intersection(qs1)), 0)\n-        self.assertEqual(len(qs2.intersection(qs2)), 0)\n-        self.assertEqual(len(qs3.intersection(qs3)), 0)\n-\n-    @skipUnlessDBFeature('supports_select_difference')\n-    def test_difference_with_empty_qs(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.none()\n-        qs3 = Number.objects.filter(pk__in=[])\n-        self.assertEqual(len(qs1.difference(qs2)), 10)\n-        self.assertEqual(len(qs1.difference(qs3)), 10)\n-        self.assertEqual(len(qs2.difference(qs1)), 0)\n-        self.assertEqual(len(qs3.difference(qs1)), 0)\n-        self.assertEqual(len(qs2.difference(qs2)), 0)\n-        self.assertEqual(len(qs3.difference(qs3)), 0)\n-\n-    @skipUnlessDBFeature('supports_select_difference')\n-    def test_difference_with_values(self):\n-        ReservedName.objects.create(name='a', order=2)\n-        qs1 = ReservedName.objects.all()\n-        qs2 = ReservedName.objects.none()\n-        reserved_name = qs1.difference(qs2).values('name', 'order', 'id').get()\n-        self.assertEqual(reserved_name['name'], 'a')\n-        self.assertEqual(reserved_name['order'], 2)\n-        reserved_name = qs1.difference(qs2).values_list('name', 'order', 'id').get()\n-        self.assertEqual(reserved_name[:2], ('a', 2))\n-\n-    def test_union_with_empty_qs(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.none()\n-        qs3 = Number.objects.filter(pk__in=[])\n-        self.assertEqual(len(qs1.union(qs2)), 10)\n-        self.assertEqual(len(qs2.union(qs1)), 10)\n-        self.assertEqual(len(qs1.union(qs3)), 10)\n-        self.assertEqual(len(qs3.union(qs1)), 10)\n-        self.assertEqual(len(qs2.union(qs1, qs1, qs1)), 10)\n-        self.assertEqual(len(qs2.union(qs1, qs1, all=True)), 20)\n-        self.assertEqual(len(qs2.union(qs2)), 0)\n-        self.assertEqual(len(qs3.union(qs3)), 0)\n-\n-    def test_limits(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.all()\n-        self.assertEqual(len(list(qs1.union(qs2)[:2])), 2)\n-\n-    def test_ordering(self):\n-        qs1 = Number.objects.filter(num__lte=1)\n-        qs2 = Number.objects.filter(num__gte=2, num__lte=3)\n-        self.assertNumbersEqual(qs1.union(qs2).order_by('-num'), [3, 2, 1, 0])\n-\n-    def test_ordering_by_f_expression(self):\n-        qs1 = Number.objects.filter(num__lte=1)\n-        qs2 = Number.objects.filter(num__gte=2, num__lte=3)\n-        self.assertNumbersEqual(qs1.union(qs2).order_by(F('num').desc()), [3, 2, 1, 0])\n-\n-    def test_union_with_values(self):\n-        ReservedName.objects.create(name='a', order=2)\n-        qs1 = ReservedName.objects.all()\n-        reserved_name = qs1.union(qs1).values('name', 'order', 'id').get()\n-        self.assertEqual(reserved_name['name'], 'a')\n-        self.assertEqual(reserved_name['order'], 2)\n-        reserved_name = qs1.union(qs1).values_list('name', 'order', 'id').get()\n-        self.assertEqual(reserved_name[:2], ('a', 2))\n-        # List of columns can be changed.\n-        reserved_name = qs1.union(qs1).values_list('order').get()\n-        self.assertEqual(reserved_name, (2,))\n-\n-    def test_union_with_two_annotated_values_list(self):\n-        qs1 = Number.objects.filter(num=1).annotate(\n-            count=Value(0, IntegerField()),\n-        ).values_list('num', 'count')\n-        qs2 = Number.objects.filter(num=2).values('pk').annotate(\n-            count=F('num'),\n-        ).annotate(\n-            num=Value(1, IntegerField()),\n-        ).values_list('num', 'count')\n-        self.assertCountEqual(qs1.union(qs2), [(1, 0), (2, 1)])\n-\n-    def test_union_with_extra_and_values_list(self):\n-        qs1 = Number.objects.filter(num=1).extra(\n-            select={'count': 0},\n-        ).values_list('num', 'count')\n-        qs2 = Number.objects.filter(num=2).extra(select={'count': 1})\n-        self.assertCountEqual(qs1.union(qs2), [(1, 0), (2, 1)])\n-\n-    def test_union_with_values_list_on_annotated_and_unannotated(self):\n-        ReservedName.objects.create(name='rn1', order=1)\n-        qs1 = Number.objects.annotate(\n-            has_reserved_name=Exists(ReservedName.objects.filter(order=OuterRef('num')))\n-        ).filter(has_reserved_name=True)\n-        qs2 = Number.objects.filter(num=9)\n-        self.assertCountEqual(qs1.union(qs2).values_list('num', flat=True), [1, 9])\n-\n-    def test_union_with_values_list_and_order(self):\n-        ReservedName.objects.bulk_create([\n-            ReservedName(name='rn1', order=7),\n-            ReservedName(name='rn2', order=5),\n-            ReservedName(name='rn0', order=6),\n-            ReservedName(name='rn9', order=-1),\n-        ])\n-        qs1 = ReservedName.objects.filter(order__gte=6)\n-        qs2 = ReservedName.objects.filter(order__lte=5)\n-        union_qs = qs1.union(qs2)\n-        for qs, expected_result in (\n-            # Order by a single column.\n-            (union_qs.order_by('-pk').values_list('order', flat=True), [-1, 6, 5, 7]),\n-            (union_qs.order_by('pk').values_list('order', flat=True), [7, 5, 6, -1]),\n-            (union_qs.values_list('order', flat=True).order_by('-pk'), [-1, 6, 5, 7]),\n-            (union_qs.values_list('order', flat=True).order_by('pk'), [7, 5, 6, -1]),\n-            # Order by multiple columns.\n-            (union_qs.order_by('-name', 'pk').values_list('order', flat=True), [-1, 5, 7, 6]),\n-            (union_qs.values_list('order', flat=True).order_by('-name', 'pk'), [-1, 5, 7, 6]),\n-        ):\n-            with self.subTest(qs=qs):\n-                self.assertEqual(list(qs), expected_result)\n-\n-    def test_count_union(self):\n-        qs1 = Number.objects.filter(num__lte=1).values('num')\n-        qs2 = Number.objects.filter(num__gte=2, num__lte=3).values('num')\n-        self.assertEqual(qs1.union(qs2).count(), 4)\n-\n-    def test_count_union_empty_result(self):\n-        qs = Number.objects.filter(pk__in=[])\n-        self.assertEqual(qs.union(qs).count(), 0)\n-\n-    @skipUnlessDBFeature('supports_select_difference')\n-    def test_count_difference(self):\n-        qs1 = Number.objects.filter(num__lt=10)\n-        qs2 = Number.objects.filter(num__lt=9)\n-        self.assertEqual(qs1.difference(qs2).count(), 1)\n-\n-    @skipUnlessDBFeature('supports_select_intersection')\n-    def test_count_intersection(self):\n-        qs1 = Number.objects.filter(num__gte=5)\n-        qs2 = Number.objects.filter(num__lte=5)\n-        self.assertEqual(qs1.intersection(qs2).count(), 1)\n-\n-    @skipUnlessDBFeature('supports_slicing_ordering_in_compound')\n-    def test_ordering_subqueries(self):\n-        qs1 = Number.objects.order_by('num')[:2]\n-        qs2 = Number.objects.order_by('-num')[:2]\n-        self.assertNumbersEqual(qs1.union(qs2).order_by('-num')[:4], [9, 8, 1, 0])\n-\n-    @skipIfDBFeature('supports_slicing_ordering_in_compound')\n-    def test_unsupported_ordering_slicing_raises_db_error(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.all()\n-        msg = 'LIMIT/OFFSET not allowed in subqueries of compound statements'\n-        with self.assertRaisesMessage(DatabaseError, msg):\n-            list(qs1.union(qs2[:10]))\n-        msg = 'ORDER BY not allowed in subqueries of compound statements'\n-        with self.assertRaisesMessage(DatabaseError, msg):\n-            list(qs1.order_by('id').union(qs2))\n-\n-    @skipIfDBFeature('supports_select_intersection')\n-    def test_unsupported_intersection_raises_db_error(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.all()\n-        msg = 'intersection is not supported on this database backend'\n-        with self.assertRaisesMessage(NotSupportedError, msg):\n-            list(qs1.intersection(qs2))\n-\n-    def test_combining_multiple_models(self):\n-        ReservedName.objects.create(name='99 little bugs', order=99)\n-        qs1 = Number.objects.filter(num=1).values_list('num', flat=True)\n-        qs2 = ReservedName.objects.values_list('order')\n-        self.assertEqual(list(qs1.union(qs2).order_by('num')), [1, 99])\n-\n-    def test_order_raises_on_non_selected_column(self):\n-        qs1 = Number.objects.filter().annotate(\n-            annotation=Value(1, IntegerField()),\n-        ).values('annotation', num2=F('num'))\n-        qs2 = Number.objects.filter().values('id', 'num')\n-        # Should not raise\n-        list(qs1.union(qs2).order_by('annotation'))\n-        list(qs1.union(qs2).order_by('num2'))\n-        msg = 'ORDER BY term does not match any column in the result set'\n-        # 'id' is not part of the select\n-        with self.assertRaisesMessage(DatabaseError, msg):\n-            list(qs1.union(qs2).order_by('id'))\n-        # 'num' got realiased to num2\n-        with self.assertRaisesMessage(DatabaseError, msg):\n-            list(qs1.union(qs2).order_by('num'))\n-        # switched order, now 'exists' again:\n-        list(qs2.union(qs1).order_by('num'))\n-\n-    @skipUnlessDBFeature('supports_select_difference', 'supports_select_intersection')\n-    def test_qs_with_subcompound_qs(self):\n-        qs1 = Number.objects.all()\n-        qs2 = Number.objects.intersection(Number.objects.filter(num__gt=1))\n-        self.assertEqual(qs1.difference(qs2).count(), 2)\n-\n-    def test_order_by_same_type(self):\n-        qs = Number.objects.all()\n-        union = qs.union(qs)\n-        numbers = list(range(10))\n-        self.assertNumbersEqual(union.order_by('num'), numbers)\n-        self.assertNumbersEqual(union.order_by('other_num'), reversed(numbers))\n-\n-    def test_unsupported_operations_on_combined_qs(self):\n-        qs = Number.objects.all()\n-        msg = 'Calling QuerySet.%s() after %s() is not supported.'\n-        combinators = ['union']\n-        if connection.features.supports_select_difference:\n-            combinators.append('difference')\n-        if connection.features.supports_select_intersection:\n-            combinators.append('intersection')\n-        for combinator in combinators:\n-            for operation in (\n-                'annotate',\n-                'defer',\n-                'exclude',\n-                'extra',\n-                'filter',\n-                'only',\n-                'prefetch_related',\n-                'select_related',\n-            ):\n-                with self.subTest(combinator=combinator, operation=operation):\n-                    with self.assertRaisesMessage(\n-                        NotSupportedError,\n-                        msg % (operation, combinator),\n-                    ):\n-                        getattr(getattr(qs, combinator)(qs), operation)()\n+from django.db.models import OuterRef, Subquery\n+from django.test import TestCase\n+from .models import Number, Item, Tag, Category\n+\n+class TestExists(TestCase):\n+    def test_exists_exclude(self):\n+        # filter()\n+        qs = Number.objects.annotate(\n+            foo=Subquery(\n+                Item.objects.filter(tags__category_id=OuterRef('pk')).values('pk')[:1]\n+            )\n+        ).filter(foo__isnull=False)\n+        print(qs) # works\n+        # exclude()\n+        qs = Number.objects.annotate(\n+            foo =Subquery(\n+                Item.objects.exclude(tags__category_id=OuterRef('pk')).values('pk')[:1]\n+            )\n+        ).filter(foo__isnull=False)\n+        print(qs) # works\n+        # filter(~Q())\n+        qs = Number.objects.annotate(\n+            foo =Subquery(\n+                Item.objects.filter(~Q(tags__category_id=OuterRef('pk'))).values('pk')[:1]\n+            )\n+        ).filter(foo__isnull=False)\n+        print(qs) # works\n"}
{"instance_id": "django__django-11749", "model_name_or_path": "cain-anthropic-e124", "model_patch": "diff --git a/django/core/management/__init__.py b/django/core/management/__init__.py\nindex 5f2e64761e..adc7d173eb 100644\n--- a/django/core/management/__init__.py\n+++ b/django/core/management/__init__.py\n@@ -130,11 +130,19 @@ def call_command(command_name, *args, **options):\n                 yield opt\n \n     parser_actions = list(get_actions(parser))\n+    mutually_exclusive_required_options = {\n+        opt\n+        for group in parser._mutually_exclusive_groups\n+        for opt in group._group_actions if group.required\n+    }\n     # Any required arguments which are passed in via **options must be passed\n     # to parse_args().\n     parse_args += [\n         '{}={}'.format(min(opt.option_strings), arg_options[opt.dest])\n-        for opt in parser_actions if opt.required and opt.dest in options\n+        for opt in parser_actions if (\n+            opt.dest in options and\n+            (opt.required or opt in mutually_exclusive_required_options)\n+        )\n     ]\n     defaults = parser.parse_args(args=parse_args)\n     defaults = dict(defaults._get_kwargs(), **arg_options)\n", "model": "claude-sonnet-5-5", "steps": 8, "finished": true, "patch_lines": 25, "candidates": [{"compile_ok": 0, "loc_hits": 0, "files": 1, "diff_lines": 25, "steps": 8}], "ms": 20528}
{"instance_id": "django__django-11790", "model_name_or_path": "cain-anthropic-e124", "model_patch": "diff --git a/django/contrib/auth/forms.py b/django/contrib/auth/forms.py\nindex a0cfed0995..b4fb55c1b4 100644\n--- a/django/contrib/auth/forms.py\n+++ b/django/contrib/auth/forms.py\n@@ -191,7 +191,9 @@ class AuthenticationForm(forms.Form):\n \n         # Set the max length and label for the \"username\" field.\n         self.username_field = UserModel._meta.get_field(UserModel.USERNAME_FIELD)\n-        self.fields['username'].max_length = self.username_field.max_length or 254\n+        username_max_length = self.username_field.max_length or 254\n+        self.fields['username'].max_length = username_max_length\n+        self.fields['username'].widget.attrs['maxlength'] = username_max_length\n         if self.fields['username'].label is None:\n             self.fields['username'].label = capfirst(self.username_field.verbose_name)\n \n", "model": "claude-sonnet-5-5", "steps": 4, "finished": true, "patch_lines": 15, "candidates": [{"compile_ok": 0, "loc_hits": 0, "files": 1, "diff_lines": 15, "steps": 4}], "ms": 14422}
{"instance_id": "django__django-11815", "model_name_or_path": "cain-anthropic-e124", "model_patch": "diff --git a/django/db/migrations/serializer.py b/django/db/migrations/serializer.py\nindex 27b5cbd379..e69de29bb2 100644\n--- a/django/db/migrations/serializer.py\n+++ b/django/db/migrations/serializer.py\n@@ -1,339 +0,0 @@\n-import builtins\n-import collections.abc\n-import datetime\n-import decimal\n-import enum\n-import functools\n-import math\n-import re\n-import types\n-import uuid\n-\n-from django.conf import SettingsReference\n-from django.db import models\n-from django.db.migrations.operations.base import Operation\n-from django.db.migrations.utils import COMPILED_REGEX_TYPE, RegexObject\n-from django.utils.functional import LazyObject, Promise\n-from django.utils.timezone import utc\n-from django.utils.version import get_docs_version\n-\n-\n-class BaseSerializer:\n-    def __init__(self, value):\n-        self.value = value\n-\n-    def serialize(self):\n-        raise NotImplementedError('Subclasses of BaseSerializer must implement the serialize() method.')\n-\n-\n-class BaseSequenceSerializer(BaseSerializer):\n-    def _format(self):\n-        raise NotImplementedError('Subclasses of BaseSequenceSerializer must implement the _format() method.')\n-\n-    def serialize(self):\n-        imports = set()\n-        strings = []\n-        for item in self.value:\n-            item_string, item_imports = serializer_factory(item).serialize()\n-            imports.update(item_imports)\n-            strings.append(item_string)\n-        value = self._format()\n-        return value % (\", \".join(strings)), imports\n-\n-\n-class BaseSimpleSerializer(BaseSerializer):\n-    def serialize(self):\n-        return repr(self.value), set()\n-\n-\n-class ChoicesSerializer(BaseSerializer):\n-    def serialize(self):\n-        return serializer_factory(self.value.value).serialize()\n-\n-\n-class DateTimeSerializer(BaseSerializer):\n-    \"\"\"For datetime.*, except datetime.datetime.\"\"\"\n-    def serialize(self):\n-        return repr(self.value), {'import datetime'}\n-\n-\n-class DatetimeDatetimeSerializer(BaseSerializer):\n-    \"\"\"For datetime.datetime.\"\"\"\n-    def serialize(self):\n-        if self.value.tzinfo is not None and self.value.tzinfo != utc:\n-            self.value = self.value.astimezone(utc)\n-        imports = [\"import datetime\"]\n-        if self.value.tzinfo is not None:\n-            imports.append(\"from django.utils.timezone import utc\")\n-        return repr(self.value).replace('<UTC>', 'utc'), set(imports)\n-\n-\n-class DecimalSerializer(BaseSerializer):\n-    def serialize(self):\n-        return repr(self.value), {\"from decimal import Decimal\"}\n-\n-\n-class DeconstructableSerializer(BaseSerializer):\n-    @staticmethod\n-    def serialize_deconstructed(path, args, kwargs):\n-        name, imports = DeconstructableSerializer._serialize_path(path)\n-        strings = []\n-        for arg in args:\n-            arg_string, arg_imports = serializer_factory(arg).serialize()\n-            strings.append(arg_string)\n-            imports.update(arg_imports)\n-        for kw, arg in sorted(kwargs.items()):\n-            arg_string, arg_imports = serializer_factory(arg).serialize()\n-            imports.update(arg_imports)\n-            strings.append(\"%s=%s\" % (kw, arg_string))\n-        return \"%s(%s)\" % (name, \", \".join(strings)), imports\n-\n-    @staticmethod\n-    def _serialize_path(path):\n-        module, name = path.rsplit(\".\", 1)\n-        if module == \"django.db.models\":\n-            imports = {\"from django.db import models\"}\n-            name = \"models.%s\" % name\n-        else:\n-            imports = {\"import %s\" % module}\n-            name = path\n-        return name, imports\n-\n-    def serialize(self):\n-        return self.serialize_deconstructed(*self.value.deconstruct())\n-\n-\n-class DictionarySerializer(BaseSerializer):\n-    def serialize(self):\n-        imports = set()\n-        strings = []\n-        for k, v in sorted(self.value.items()):\n-            k_string, k_imports = serializer_factory(k).serialize()\n-            v_string, v_imports = serializer_factory(v).serialize()\n-            imports.update(k_imports)\n-            imports.update(v_imports)\n-            strings.append((k_string, v_string))\n-        return \"{%s}\" % (\", \".join(\"%s: %s\" % (k, v) for k, v in strings)), imports\n-\n-\n-class EnumSerializer(BaseSerializer):\n-    def serialize(self):\n-        enum_class = self.value.__class__\n-        module = enum_class.__module__\n-        v_string, v_imports = serializer_factory(self.value.value).serialize()\n-        imports = {'import %s' % module, *v_imports}\n-        return \"%s.%s(%s)\" % (module, enum_class.__name__, v_string), imports\n-\n-\n-class FloatSerializer(BaseSimpleSerializer):\n-    def serialize(self):\n-        if math.isnan(self.value) or math.isinf(self.value):\n-            return 'float(\"{}\")'.format(self.value), set()\n-        return super().serialize()\n-\n-\n-class FrozensetSerializer(BaseSequenceSerializer):\n-    def _format(self):\n-        return \"frozenset([%s])\"\n-\n-\n-class FunctionTypeSerializer(BaseSerializer):\n-    def serialize(self):\n-        if getattr(self.value, \"__self__\", None) and isinstance(self.value.__self__, type):\n-            klass = self.value.__self__\n-            module = klass.__module__\n-            return \"%s.%s.%s\" % (module, klass.__name__, self.value.__name__), {\"import %s\" % module}\n-        # Further error checking\n-        if self.value.__name__ == '<lambda>':\n-            raise ValueError(\"Cannot serialize function: lambda\")\n-        if self.value.__module__ is None:\n-            raise ValueError(\"Cannot serialize function %r: No module\" % self.value)\n-\n-        module_name = self.value.__module__\n-\n-        if '<' not in self.value.__qualname__:  # Qualname can include <locals>\n-            return '%s.%s' % (module_name, self.value.__qualname__), {'import %s' % self.value.__module__}\n-\n-        raise ValueError(\n-            'Could not find function %s in %s.\\n' % (self.value.__name__, module_name)\n-        )\n-\n-\n-class FunctoolsPartialSerializer(BaseSerializer):\n-    def serialize(self):\n-        # Serialize functools.partial() arguments\n-        func_string, func_imports = serializer_factory(self.value.func).serialize()\n-        args_string, args_imports = serializer_factory(self.value.args).serialize()\n-        keywords_string, keywords_imports = serializer_factory(self.value.keywords).serialize()\n-        # Add any imports needed by arguments\n-        imports = {'import functools', *func_imports, *args_imports, *keywords_imports}\n-        return (\n-            'functools.%s(%s, *%s, **%s)' % (\n-                self.value.__class__.__name__,\n-                func_string,\n-                args_string,\n-                keywords_string,\n-            ),\n-            imports,\n-        )\n-\n-\n-class IterableSerializer(BaseSerializer):\n-    def serialize(self):\n-        imports = set()\n-        strings = []\n-        for item in self.value:\n-            item_string, item_imports = serializer_factory(item).serialize()\n-            imports.update(item_imports)\n-            strings.append(item_string)\n-        # When len(strings)==0, the empty iterable should be serialized as\n-        # \"()\", not \"(,)\" because (,) is invalid Python syntax.\n-        value = \"(%s)\" if len(strings) != 1 else \"(%s,)\"\n-        return value % (\", \".join(strings)), imports\n-\n-\n-class ModelFieldSerializer(DeconstructableSerializer):\n-    def serialize(self):\n-        attr_name, path, args, kwargs = self.value.deconstruct()\n-        return self.serialize_deconstructed(path, args, kwargs)\n-\n-\n-class ModelManagerSerializer(DeconstructableSerializer):\n-    def serialize(self):\n-        as_manager, manager_path, qs_path, args, kwargs = self.value.deconstruct()\n-        if as_manager:\n-            name, imports = self._serialize_path(qs_path)\n-            return \"%s.as_manager()\" % name, imports\n-        else:\n-            return self.serialize_deconstructed(manager_path, args, kwargs)\n-\n-\n-class OperationSerializer(BaseSerializer):\n-    def serialize(self):\n-        from django.db.migrations.writer import OperationWriter\n-        string, imports = OperationWriter(self.value, indentation=0).serialize()\n-        # Nested operation, trailing comma is handled in upper OperationWriter._write()\n-        return string.rstrip(','), imports\n-\n-\n-class RegexSerializer(BaseSerializer):\n-    def serialize(self):\n-        regex_pattern, pattern_imports = serializer_factory(self.value.pattern).serialize()\n-        # Turn off default implicit flags (e.g. re.U) because regexes with the\n-        # same implicit and explicit flags aren't equal.\n-        flags = self.value.flags ^ re.compile('').flags\n-        regex_flags, flag_imports = serializer_factory(flags).serialize()\n-        imports = {'import re', *pattern_imports, *flag_imports}\n-        args = [regex_pattern]\n-        if flags:\n-            args.append(regex_flags)\n-        return \"re.compile(%s)\" % ', '.join(args), imports\n-\n-\n-class SequenceSerializer(BaseSequenceSerializer):\n-    def _format(self):\n-        return \"[%s]\"\n-\n-\n-class SetSerializer(BaseSequenceSerializer):\n-    def _format(self):\n-        # Serialize as a set literal except when value is empty because {}\n-        # is an empty dict.\n-        return '{%s}' if self.value else 'set(%s)'\n-\n-\n-class SettingsReferenceSerializer(BaseSerializer):\n-    def serialize(self):\n-        return \"settings.%s\" % self.value.setting_name, {\"from django.conf import settings\"}\n-\n-\n-class TupleSerializer(BaseSequenceSerializer):\n-    def _format(self):\n-        # When len(value)==0, the empty tuple should be serialized as \"()\",\n-        # not \"(,)\" because (,) is invalid Python syntax.\n-        return \"(%s)\" if len(self.value) != 1 else \"(%s,)\"\n-\n-\n-class TypeSerializer(BaseSerializer):\n-    def serialize(self):\n-        special_cases = [\n-            (models.Model, \"models.Model\", []),\n-            (type(None), 'type(None)', []),\n-        ]\n-        for case, string, imports in special_cases:\n-            if case is self.value:\n-                return string, set(imports)\n-        if hasattr(self.value, \"__module__\"):\n-            module = self.value.__module__\n-            if module == builtins.__name__:\n-                return self.value.__name__, set()\n-            else:\n-                return \"%s.%s\" % (module, self.value.__name__), {\"import %s\" % module}\n-\n-\n-class UUIDSerializer(BaseSerializer):\n-    def serialize(self):\n-        return \"uuid.%s\" % repr(self.value), {\"import uuid\"}\n-\n-\n-class Serializer:\n-    _registry = {\n-        # Some of these are order-dependent.\n-        frozenset: FrozensetSerializer,\n-        list: SequenceSerializer,\n-        set: SetSerializer,\n-        tuple: TupleSerializer,\n-        dict: DictionarySerializer,\n-        models.Choices: ChoicesSerializer,\n-        enum.Enum: EnumSerializer,\n-        datetime.datetime: DatetimeDatetimeSerializer,\n-        (datetime.date, datetime.timedelta, datetime.time): DateTimeSerializer,\n-        SettingsReference: SettingsReferenceSerializer,\n-        float: FloatSerializer,\n-        (bool, int, type(None), bytes, str, range): BaseSimpleSerializer,\n-        decimal.Decimal: DecimalSerializer,\n-        (functools.partial, functools.partialmethod): FunctoolsPartialSerializer,\n-        (types.FunctionType, types.BuiltinFunctionType, types.MethodType): FunctionTypeSerializer,\n-        collections.abc.Iterable: IterableSerializer,\n-        (COMPILED_REGEX_TYPE, RegexObject): RegexSerializer,\n-        uuid.UUID: UUIDSerializer,\n-    }\n-\n-    @classmethod\n-    def register(cls, type_, serializer):\n-        if not issubclass(serializer, BaseSerializer):\n-            raise ValueError(\"'%s' must inherit from 'BaseSerializer'.\" % serializer.__name__)\n-        cls._registry[type_] = serializer\n-\n-    @classmethod\n-    def unregister(cls, type_):\n-        cls._registry.pop(type_)\n-\n-\n-def serializer_factory(value):\n-    if isinstance(value, Promise):\n-        value = str(value)\n-    elif isinstance(value, LazyObject):\n-        # The unwrapped value is returned as the first item of the arguments\n-        # tuple.\n-        value = value.__reduce__()[1][0]\n-\n-    if isinstance(value, models.Field):\n-        return ModelFieldSerializer(value)\n-    if isinstance(value, models.manager.BaseManager):\n-        return ModelManagerSerializer(value)\n-    if isinstance(value, Operation):\n-        return OperationSerializer(value)\n-    if isinstance(value, type):\n-        return TypeSerializer(value)\n-    # Anything that knows how to deconstruct itself.\n-    if hasattr(value, 'deconstruct'):\n-        return DeconstructableSerializer(value)\n-    for type_, serializer_cls in Serializer._registry.items():\n-        if isinstance(value, type_):\n-            return serializer_cls(value)\n-    raise ValueError(\n-        \"Cannot serialize: %r\\nThere are some values Django cannot serialize into \"\n-        \"migration files.\\nFor more, see https://docs.djangoproject.com/en/%s/\"\n-        \"topics/migrations/#migration-serializing\" % (value, get_docs_version())\n-    )\n", "model": "claude-sonnet-5-5", "steps": 16, "finished": false, "patch_lines": 344, "candidates": [{"compile_ok": 0, "loc_hits": 0, "files": 1, "diff_lines": 344, "steps": 16}], "ms": 118912}
{"instance_id": "django__django-11820", "model_name_or_path": "cain-anthropic-e124", "model_patch": "diff --git a/django/db/models/base.py b/django/db/models/base.py\nindex 3ce711f3f1..311c8dd065 100644\n--- a/django/db/models/base.py\n+++ b/django/db/models/base.py\n@@ -1,1903 +1 @@\n-import copy\n-import inspect\n-import warnings\n-from functools import partialmethod\n-from itertools import chain\n-\n-from django.apps import apps\n-from django.conf import settings\n-from django.core import checks\n-from django.core.exceptions import (\n-    NON_FIELD_ERRORS, FieldDoesNotExist, FieldError, MultipleObjectsReturned,\n-    ObjectDoesNotExist, ValidationError,\n-)\n-from django.db import (\n-    DEFAULT_DB_ALIAS, DJANGO_VERSION_PICKLE_KEY, DatabaseError, connection,\n-    connections, router, transaction,\n-)\n-from django.db.models import (\n-    NOT_PROVIDED, ExpressionWrapper, IntegerField, Max, Value,\n-)\n-from django.db.models.constants import LOOKUP_SEP\n-from django.db.models.constraints import CheckConstraint, UniqueConstraint\n-from django.db.models.deletion import CASCADE, Collector\n-from django.db.models.fields.related import (\n-    ForeignObjectRel, OneToOneField, lazy_related_operation, resolve_relation,\n-)\n-from django.db.models.functions import Coalesce\n-from django.db.models.manager import Manager\n-from django.db.models.options import Options\n-from django.db.models.query import Q\n-from django.db.models.signals import (\n-    class_prepared, post_init, post_save, pre_init, pre_save,\n-)\n-from django.db.models.utils import make_model_tuple\n-from django.utils.encoding import force_str\n-from django.utils.text import capfirst, get_text_list\n-from django.utils.translation import gettext_lazy as _\n-from django.utils.version import get_version\n-\n-\n-class Deferred:\n-    def __repr__(self):\n-        return '<Deferred field>'\n-\n-    def __str__(self):\n-        return '<Deferred field>'\n-\n-\n-DEFERRED = Deferred()\n-\n-\n-def subclass_exception(name, bases, module, attached_to):\n-    \"\"\"\n-    Create exception subclass. Used by ModelBase below.\n-\n-    The exception is created in a way that allows it to be pickled, assuming\n-    that the returned exception class will be added as an attribute to the\n-    'attached_to' class.\n-    \"\"\"\n-    return type(name, bases, {\n-        '__module__': module,\n-        '__qualname__': '%s.%s' % (attached_to.__qualname__, name),\n-    })\n-\n-\n-def _has_contribute_to_class(value):\n-    # Only call contribute_to_class() if it's bound.\n-    return not inspect.isclass(value) and hasattr(value, 'contribute_to_class')\n-\n-\n-class ModelBase(type):\n-    \"\"\"Metaclass for all models.\"\"\"\n-    def __new__(cls, name, bases, attrs, **kwargs):\n-        super_new = super().__new__\n-\n-        # Also ensure initialization is only performed for subclasses of Model\n-        # (excluding Model class itself).\n-        parents = [b for b in bases if isinstance(b, ModelBase)]\n-        if not parents:\n-            return super_new(cls, name, bases, attrs)\n-\n-        # Create the class.\n-        module = attrs.pop('__module__')\n-        new_attrs = {'__module__': module}\n-        classcell = attrs.pop('__classcell__', None)\n-        if classcell is not None:\n-            new_attrs['__classcell__'] = classcell\n-        attr_meta = attrs.pop('Meta', None)\n-        # Pass all attrs without a (Django-specific) contribute_to_class()\n-        # method to type.__new__() so that they're properly initialized\n-        # (i.e. __set_name__()).\n-        contributable_attrs = {}\n-        for obj_name, obj in list(attrs.items()):\n-            if _has_contribute_to_class(obj):\n-                contributable_attrs[obj_name] = obj\n-            else:\n-                new_attrs[obj_name] = obj\n-        new_class = super_new(cls, name, bases, new_attrs, **kwargs)\n-\n-        abstract = getattr(attr_meta, 'abstract', False)\n-        meta = attr_meta or getattr(new_class, 'Meta', None)\n-        base_meta = getattr(new_class, '_meta', None)\n-\n-        app_label = None\n-\n-        # Look for an application configuration to attach the model to.\n-        app_config = apps.get_containing_app_config(module)\n-\n-        if getattr(meta, 'app_label', None) is None:\n-            if app_config is None:\n-                if not abstract:\n-                    raise RuntimeError(\n-                        \"Model class %s.%s doesn't declare an explicit \"\n-                        \"app_label and isn't in an application in \"\n-                        \"INSTALLED_APPS.\" % (module, name)\n-                    )\n-\n-            else:\n-                app_label = app_config.label\n-\n-        new_class.add_to_class('_meta', Options(meta, app_label))\n-        if not abstract:\n-            new_class.add_to_class(\n-                'DoesNotExist',\n-                subclass_exception(\n-                    'DoesNotExist',\n-                    tuple(\n-                        x.DoesNotExist for x in parents if hasattr(x, '_meta') and not x._meta.abstract\n-                    ) or (ObjectDoesNotExist,),\n-                    module,\n-                    attached_to=new_class))\n-            new_class.add_to_class(\n-                'MultipleObjectsReturned',\n-                subclass_exception(\n-                    'MultipleObjectsReturned',\n-                    tuple(\n-                        x.MultipleObjectsReturned for x in parents if hasattr(x, '_meta') and not x._meta.abstract\n-                    ) or (MultipleObjectsReturned,),\n-                    module,\n-                    attached_to=new_class))\n-            if base_meta and not base_meta.abstract:\n-                # Non-abstract child classes inherit some attributes from their\n-                # non-abstract parent (unless an ABC comes before it in the\n-                # method resolution order).\n-                if not hasattr(meta, 'ordering'):\n-                    new_class._meta.ordering = base_meta.ordering\n-                if not hasattr(meta, 'get_latest_by'):\n-                    new_class._meta.get_latest_by = base_meta.get_latest_by\n-\n-        is_proxy = new_class._meta.proxy\n-\n-        # If the model is a proxy, ensure that the base class\n-        # hasn't been swapped out.\n-        if is_proxy and base_meta and base_meta.swapped:\n-            raise TypeError(\"%s cannot proxy the swapped model '%s'.\" % (name, base_meta.swapped))\n-\n-        # Add remaining attributes (those with a contribute_to_class() method)\n-        # to the class.\n-        for obj_name, obj in contributable_attrs.items():\n-            new_class.add_to_class(obj_name, obj)\n-\n-        # All the fields of any type declared on this model\n-        new_fields = chain(\n-            new_class._meta.local_fields,\n-            new_class._meta.local_many_to_many,\n-            new_class._meta.private_fields\n-        )\n-        field_names = {f.name for f in new_fields}\n-\n-        # Basic setup for proxy models.\n-        if is_proxy:\n-            base = None\n-            for parent in [kls for kls in parents if hasattr(kls, '_meta')]:\n-                if parent._meta.abstract:\n-                    if parent._meta.fields:\n-                        raise TypeError(\n-                            \"Abstract base class containing model fields not \"\n-                            \"permitted for proxy model '%s'.\" % name\n-                        )\n-                    else:\n-                        continue\n-                if base is None:\n-                    base = parent\n-                elif parent._meta.concrete_model is not base._meta.concrete_model:\n-                    raise TypeError(\"Proxy model '%s' has more than one non-abstract model base class.\" % name)\n-            if base is None:\n-                raise TypeError(\"Proxy model '%s' has no non-abstract model base class.\" % name)\n-            new_class._meta.setup_proxy(base)\n-            new_class._meta.concrete_model = base._meta.concrete_model\n-        else:\n-            new_class._meta.concrete_model = new_class\n-\n-        # Collect the parent links for multi-table inheritance.\n-        parent_links = {}\n-        for base in reversed([new_class] + parents):\n-            # Conceptually equivalent to `if base is Model`.\n-            if not hasattr(base, '_meta'):\n-                continue\n-            # Skip concrete parent classes.\n-            if base != new_class and not base._meta.abstract:\n-                continue\n-            # Locate OneToOneField instances.\n-            for field in base._meta.local_fields:\n-                if isinstance(field, OneToOneField):\n-                    related = resolve_relation(new_class, field.remote_field.model)\n-                    parent_links[make_model_tuple(related)] = field\n-\n-        # Track fields inherited from base models.\n-        inherited_attributes = set()\n-        # Do the appropriate setup for any model parents.\n-        for base in new_class.mro():\n-            if base not in parents or not hasattr(base, '_meta'):\n-                # Things without _meta aren't functional models, so they're\n-                # uninteresting parents.\n-                inherited_attributes.update(base.__dict__)\n-                continue\n-\n-            parent_fields = base._meta.local_fields + base._meta.local_many_to_many\n-            if not base._meta.abstract:\n-                # Check for clashes between locally declared fields and those\n-                # on the base classes.\n-                for field in parent_fields:\n-                    if field.name in field_names:\n-                        raise FieldError(\n-                            'Local field %r in class %r clashes with field of '\n-                            'the same name from base class %r.' % (\n-                                field.name,\n-                                name,\n-                                base.__name__,\n-                            )\n-                        )\n-                    else:\n-                        inherited_attributes.add(field.name)\n-\n-                # Concrete classes...\n-                base = base._meta.concrete_model\n-                base_key = make_model_tuple(base)\n-                if base_key in parent_links:\n-                    field = parent_links[base_key]\n-                elif not is_proxy:\n-                    attr_name = '%s_ptr' % base._meta.model_name\n-                    field = OneToOneField(\n-                        base,\n-                        on_delete=CASCADE,\n-                        name=attr_name,\n-                        auto_created=True,\n-                        parent_link=True,\n-                    )\n-\n-                    if attr_name in field_names:\n-                        raise FieldError(\n-                            \"Auto-generated field '%s' in class %r for \"\n-                            \"parent_link to base class %r clashes with \"\n-                            \"declared field of the same name.\" % (\n-                                attr_name,\n-                                name,\n-                                base.__name__,\n-                            )\n-                        )\n-\n-                    # Only add the ptr field if it's not already present;\n-                    # e.g. migrations will already have it specified\n-                    if not hasattr(new_class, attr_name):\n-                        new_class.add_to_class(attr_name, field)\n-                else:\n-                    field = None\n-                new_class._meta.parents[base] = field\n-            else:\n-                base_parents = base._meta.parents.copy()\n-\n-                # Add fields from abstract base class if it wasn't overridden.\n-                for field in parent_fields:\n-                    if (field.name not in field_names and\n-                            field.name not in new_class.__dict__ and\n-                            field.name not in inherited_attributes):\n-                        new_field = copy.deepcopy(field)\n-                        new_class.add_to_class(field.name, new_field)\n-                        # Replace parent links defined on this base by the new\n-                        # field. It will be appropriately resolved if required.\n-                        if field.one_to_one:\n-                            for parent, parent_link in base_parents.items():\n-                                if field == parent_link:\n-                                    base_parents[parent] = new_field\n-\n-                # Pass any non-abstract parent classes onto child.\n-                new_class._meta.parents.update(base_parents)\n-\n-            # Inherit private fields (like GenericForeignKey) from the parent\n-            # class\n-            for field in base._meta.private_fields:\n-                if field.name in field_names:\n-                    if not base._meta.abstract:\n-                        raise FieldError(\n-                            'Local field %r in class %r clashes with field of '\n-                            'the same name from base class %r.' % (\n-                                field.name,\n-                                name,\n-                                base.__name__,\n-                            )\n-                        )\n-                else:\n-                    field = copy.deepcopy(field)\n-                    if not base._meta.abstract:\n-                        field.mti_inherited = True\n-                    new_class.add_to_class(field.name, field)\n-\n-        # Copy indexes so that index names are unique when models extend an\n-        # abstract model.\n-        new_class._meta.indexes = [copy.deepcopy(idx) for idx in new_class._meta.indexes]\n-\n-        if abstract:\n-            # Abstract base models can't be instantiated and don't appear in\n-            # the list of models for an app. We do the final setup for them a\n-            # little differently from normal models.\n-            attr_meta.abstract = False\n-            new_class.Meta = attr_meta\n-            return new_class\n-\n-        new_class._prepare()\n-        new_class._meta.apps.register_model(new_class._meta.app_label, new_class)\n-        return new_class\n-\n-    def add_to_class(cls, name, value):\n-        if _has_contribute_to_class(value):\n-            value.contribute_to_class(cls, name)\n-        else:\n-            setattr(cls, name, value)\n-\n-    def _prepare(cls):\n-        \"\"\"Create some methods once self._meta has been populated.\"\"\"\n-        opts = cls._meta\n-        opts._prepare(cls)\n-\n-        if opts.order_with_respect_to:\n-            cls.get_next_in_order = partialmethod(cls._get_next_or_previous_in_order, is_next=True)\n-            cls.get_previous_in_order = partialmethod(cls._get_next_or_previous_in_order, is_next=False)\n-\n-            # Defer creating accessors on the foreign class until it has been\n-            # created and registered. If remote_field is None, we're ordering\n-            # with respect to a GenericForeignKey and don't know what the\n-            # foreign class is - we'll add those accessors later in\n-            # contribute_to_class().\n-            if opts.order_with_respect_to.remote_field:\n-                wrt = opts.order_with_respect_to\n-                remote = wrt.remote_field.model\n-                lazy_related_operation(make_foreign_order_accessors, cls, remote)\n-\n-        # Give the class a docstring -- its definition.\n-        if cls.__doc__ is None:\n-            cls.__doc__ = \"%s(%s)\" % (cls.__name__, \", \".join(f.name for f in opts.fields))\n-\n-        get_absolute_url_override = settings.ABSOLUTE_URL_OVERRIDES.get(opts.label_lower)\n-        if get_absolute_url_override:\n-            setattr(cls, 'get_absolute_url', get_absolute_url_override)\n-\n-        if not opts.managers:\n-            if any(f.name == 'objects' for f in opts.fields):\n-                raise ValueError(\n-                    \"Model %s must specify a custom Manager, because it has a \"\n-                    \"field named 'objects'.\" % cls.__name__\n-                )\n-            manager = Manager()\n-            manager.auto_created = True\n-            cls.add_to_class('objects', manager)\n-\n-        # Set the name of _meta.indexes. This can't be done in\n-        # Options.contribute_to_class() because fields haven't been added to\n-        # the model at that point.\n-        for index in cls._meta.indexes:\n-            if not index.name:\n-                index.set_name_with_model(cls)\n-\n-        class_prepared.send(sender=cls)\n-\n-    @property\n-    def _base_manager(cls):\n-        return cls._meta.base_manager\n-\n-    @property\n-    def _default_manager(cls):\n-        return cls._meta.default_manager\n-\n-\n-class ModelStateFieldsCacheDescriptor:\n-    def __get__(self, instance, cls=None):\n-        if instance is None:\n-            return self\n-        res = instance.fields_cache = {}\n-        return res\n-\n-\n-class ModelState:\n-    \"\"\"Store model instance state.\"\"\"\n-    db = None\n-    # If true, uniqueness validation checks will consider this a new, unsaved\n-    # object. Necessary for correct validation of new instances of objects with\n-    # explicit (non-auto) PKs. This impacts validation only; it has no effect\n-    # on the actual save.\n-    adding = True\n-    fields_cache = ModelStateFieldsCacheDescriptor()\n-\n-\n-class Model(metaclass=ModelBase):\n-\n-    def __init__(self, *args, **kwargs):\n-        # Alias some things as locals to avoid repeat global lookups\n-        cls = self.__class__\n-        opts = self._meta\n-        _setattr = setattr\n-        _DEFERRED = DEFERRED\n-\n-        pre_init.send(sender=cls, args=args, kwargs=kwargs)\n-\n-        # Set up the storage for instance state\n-        self._state = ModelState()\n-\n-        # There is a rather weird disparity here; if kwargs, it's set, then args\n-        # overrides it. It should be one or the other; don't duplicate the work\n-        # The reason for the kwargs check is that standard iterator passes in by\n-        # args, and instantiation for iteration is 33% faster.\n-        if len(args) > len(opts.concrete_fields):\n-            # Daft, but matches old exception sans the err msg.\n-            raise IndexError(\"Number of args exceeds number of fields\")\n-\n-        if not kwargs:\n-            fields_iter = iter(opts.concrete_fields)\n-            # The ordering of the zip calls matter - zip throws StopIteration\n-            # when an iter throws it. So if the first iter throws it, the second\n-            # is *not* consumed. We rely on this, so don't change the order\n-            # without changing the logic.\n-            for val, field in zip(args, fields_iter):\n-                if val is _DEFERRED:\n-                    continue\n-                _setattr(self, field.attname, val)\n-        else:\n-            # Slower, kwargs-ready version.\n-            fields_iter = iter(opts.fields)\n-            for val, field in zip(args, fields_iter):\n-                if val is _DEFERRED:\n-                    continue\n-                _setattr(self, field.attname, val)\n-                kwargs.pop(field.name, None)\n-\n-        # Now we're left with the unprocessed fields that *must* come from\n-        # keywords, or default.\n-\n-        for field in fields_iter:\n-            is_related_object = False\n-            # Virtual field\n-            if field.attname not in kwargs and field.column is None:\n-                continue\n-            if kwargs:\n-                if isinstance(field.remote_field, ForeignObjectRel):\n-                    try:\n-                        # Assume object instance was passed in.\n-                        rel_obj = kwargs.pop(field.name)\n-                        is_related_object = True\n-                    except KeyError:\n-                        try:\n-                            # Object instance wasn't passed in -- must be an ID.\n-                            val = kwargs.pop(field.attname)\n-                        except KeyError:\n-                            val = field.get_default()\n-                else:\n-                    try:\n-                        val = kwargs.pop(field.attname)\n-                    except KeyError:\n-                        # This is done with an exception rather than the\n-                        # default argument on pop because we don't want\n-                        # get_default() to be evaluated, and then not used.\n-                        # Refs #12057.\n-                        val = field.get_default()\n-            else:\n-                val = field.get_default()\n-\n-            if is_related_object:\n-                # If we are passed a related instance, set it using the\n-                # field.name instead of field.attname (e.g. \"user\" instead of\n-                # \"user_id\") so that the object gets properly cached (and type\n-                # checked) by the RelatedObjectDescriptor.\n-                if rel_obj is not _DEFERRED:\n-                    _setattr(self, field.name, rel_obj)\n-            else:\n-                if val is not _DEFERRED:\n-                    _setattr(self, field.attname, val)\n-\n-        if kwargs:\n-            property_names = opts._property_names\n-            for prop in tuple(kwargs):\n-                try:\n-                    # Any remaining kwargs must correspond to properties or\n-                    # virtual fields.\n-                    if prop in property_names or opts.get_field(prop):\n-                        if kwargs[prop] is not _DEFERRED:\n-                            _setattr(self, prop, kwargs[prop])\n-                        del kwargs[prop]\n-                except (AttributeError, FieldDoesNotExist):\n-                    pass\n-            for kwarg in kwargs:\n-                raise TypeError(\"%s() got an unexpected keyword argument '%s'\" % (cls.__name__, kwarg))\n-        super().__init__()\n-        post_init.send(sender=cls, instance=self)\n-\n-    @classmethod\n-    def from_db(cls, db, field_names, values):\n-        if len(values) != len(cls._meta.concrete_fields):\n-            values_iter = iter(values)\n-            values = [\n-                next(values_iter) if f.attname in field_names else DEFERRED\n-                for f in cls._meta.concrete_fields\n-            ]\n-        new = cls(*values)\n-        new._state.adding = False\n-        new._state.db = db\n-        return new\n-\n-    def __repr__(self):\n-        return '<%s: %s>' % (self.__class__.__name__, self)\n-\n-    def __str__(self):\n-        return '%s object (%s)' % (self.__class__.__name__, self.pk)\n-\n-    def __eq__(self, other):\n-        if not isinstance(other, Model):\n-            return False\n-        if self._meta.concrete_model != other._meta.concrete_model:\n-            return False\n-        my_pk = self.pk\n-        if my_pk is None:\n-            return self is other\n-        return my_pk == other.pk\n-\n-    def __hash__(self):\n-        if self.pk is None:\n-            raise TypeError(\"Model instances without primary key value are unhashable\")\n-        return hash(self.pk)\n-\n-    def __reduce__(self):\n-        data = self.__getstate__()\n-        data[DJANGO_VERSION_PICKLE_KEY] = get_version()\n-        class_id = self._meta.app_label, self._meta.object_name\n-        return model_unpickle, (class_id,), data\n-\n-    def __getstate__(self):\n-        \"\"\"Hook to allow choosing the attributes to pickle.\"\"\"\n-        return self.__dict__\n-\n-    def __setstate__(self, state):\n-        msg = None\n-        pickled_version = state.get(DJANGO_VERSION_PICKLE_KEY)\n-        if pickled_version:\n-            current_version = get_version()\n-            if current_version != pickled_version:\n-                msg = (\n-                    \"Pickled model instance's Django version %s does not match \"\n-                    \"the current version %s.\" % (pickled_version, current_version)\n-                )\n-        else:\n-            msg = \"Pickled model instance's Django version is not specified.\"\n-\n-        if msg:\n-            warnings.warn(msg, RuntimeWarning, stacklevel=2)\n-\n-        self.__dict__.update(state)\n-\n-    def _get_pk_val(self, meta=None):\n-        meta = meta or self._meta\n-        return getattr(self, meta.pk.attname)\n-\n-    def _set_pk_val(self, value):\n-        return setattr(self, self._meta.pk.attname, value)\n-\n-    pk = property(_get_pk_val, _set_pk_val)\n-\n-    def get_deferred_fields(self):\n-        \"\"\"\n-        Return a set containing names of deferred fields for this instance.\n-        \"\"\"\n-        return {\n-            f.attname for f in self._meta.concrete_fields\n-            if f.attname not in self.__dict__\n-        }\n-\n-    def refresh_from_db(self, using=None, fields=None):\n-        \"\"\"\n-        Reload field values from the database.\n-\n-        By default, the reloading happens from the database this instance was\n-        loaded from, or by the read router if this instance wasn't loaded from\n-        any database. The using parameter will override the default.\n-\n-        Fields can be used to specify which fields to reload. The fields\n-        should be an iterable of field attnames. If fields is None, then\n-        all non-deferred fields are reloaded.\n-\n-        When accessing deferred fields of an instance, the deferred loading\n-        of the field will call this method.\n-        \"\"\"\n-        if fields is None:\n-            self._prefetched_objects_cache = {}\n-        else:\n-            prefetched_objects_cache = getattr(self, '_prefetched_objects_cache', ())\n-            for field in fields:\n-                if field in prefetched_objects_cache:\n-                    del prefetched_objects_cache[field]\n-                    fields.remove(field)\n-            if not fields:\n-                return\n-            if any(LOOKUP_SEP in f for f in fields):\n-                raise ValueError(\n-                    'Found \"%s\" in fields argument. Relations and transforms '\n-                    'are not allowed in fields.' % LOOKUP_SEP)\n-\n-        hints = {'instance': self}\n-        db_instance_qs = self.__class__._base_manager.db_manager(using, hints=hints).filter(pk=self.pk)\n-\n-        # Use provided fields, if not set then reload all non-deferred fields.\n-        deferred_fields = self.get_deferred_fields()\n-        if fields is not None:\n-            fields = list(fields)\n-            db_instance_qs = db_instance_qs.only(*fields)\n-        elif deferred_fields:\n-            fields = [f.attname for f in self._meta.concrete_fields\n-                      if f.attname not in deferred_fields]\n-            db_instance_qs = db_instance_qs.only(*fields)\n-\n-        db_instance = db_instance_qs.get()\n-        non_loaded_fields = db_instance.get_deferred_fields()\n-        for field in self._meta.concrete_fields:\n-            if field.attname in non_loaded_fields:\n-                # This field wasn't refreshed - skip ahead.\n-                continue\n-            setattr(self, field.attname, getattr(db_instance, field.attname))\n-            # Clear cached foreign keys.\n-            if field.is_relation and field.is_cached(self):\n-                field.delete_cached_value(self)\n-\n-        # Clear cached relations.\n-        for field in self._meta.related_objects:\n-            if field.is_cached(self):\n-                field.delete_cached_value(self)\n-\n-        self._state.db = db_instance._state.db\n-\n-    def serializable_value(self, field_name):\n-        \"\"\"\n-        Return the value of the field name for this instance. If the field is\n-        a foreign key, return the id value instead of the object. If there's\n-        no Field object with this name on the model, return the model\n-        attribute's value.\n-\n-        Used to serialize a field's value (in the serializer, or form output,\n-        for example). Normally, you would just access the attribute directly\n-        and not use this method.\n-        \"\"\"\n-        try:\n-            field = self._meta.get_field(field_name)\n-        except FieldDoesNotExist:\n-            return getattr(self, field_name)\n-        return getattr(self, field.attname)\n-\n-    def save(self, force_insert=False, force_update=False, using=None,\n-             update_fields=None):\n-        \"\"\"\n-        Save the current instance. Override this in a subclass if you want to\n-        control the saving process.\n-\n-        The 'force_insert' and 'force_update' parameters can be used to insist\n-        that the \"save\" must be an SQL insert or update (or equivalent for\n-        non-SQL backends), respectively. Normally, they should not be set.\n-        \"\"\"\n-        # Ensure that a model instance without a PK hasn't been assigned to\n-        # a ForeignKey or OneToOneField on this model. If the field is\n-        # nullable, allowing the save() would result in silent data loss.\n-        for field in self._meta.concrete_fields:\n-            # If the related field isn't cached, then an instance hasn't\n-            # been assigned and there's no need to worry about this check.\n-            if field.is_relation and field.is_cached(self):\n-                obj = getattr(self, field.name, None)\n-                if not obj:\n-                    continue\n-                # A pk may have been assigned manually to a model instance not\n-                # saved to the database (or auto-generated in a case like\n-                # UUIDField), but we allow the save to proceed and rely on the\n-                # database to raise an IntegrityError if applicable. If\n-                # constraints aren't supported by the database, there's the\n-                # unavoidable risk of data corruption.\n-                if obj.pk is None:\n-                    # Remove the object from a related instance cache.\n-                    if not field.remote_field.multiple:\n-                        field.remote_field.delete_cached_value(obj)\n-                    raise ValueError(\n-                        \"save() prohibited to prevent data loss due to \"\n-                        \"unsaved related object '%s'.\" % field.name\n-                    )\n-                elif getattr(self, field.attname) is None:\n-                    # Use pk from related object if it has been saved after\n-                    # an assignment.\n-                    setattr(self, field.attname, obj.pk)\n-                # If the relationship's pk/to_field was changed, clear the\n-                # cached relationship.\n-                if getattr(obj, field.target_field.attname) != getattr(self, field.attname):\n-                    field.delete_cached_value(self)\n-\n-        using = using or router.db_for_write(self.__class__, instance=self)\n-        if force_insert and (force_update or update_fields):\n-            raise ValueError(\"Cannot force both insert and updating in model saving.\")\n-\n-        deferred_fields = self.get_deferred_fields()\n-        if update_fields is not None:\n-            # If update_fields is empty, skip the save. We do also check for\n-            # no-op saves later on for inheritance cases. This bailout is\n-            # still needed for skipping signal sending.\n-            if not update_fields:\n-                return\n-\n-            update_fields = frozenset(update_fields)\n-            field_names = set()\n-\n-            for field in self._meta.fields:\n-                if not field.primary_key:\n-                    field_names.add(field.name)\n-\n-                    if field.name != field.attname:\n-                        field_names.add(field.attname)\n-\n-            non_model_fields = update_fields.difference(field_names)\n-\n-            if non_model_fields:\n-                raise ValueError(\"The following fields do not exist in this \"\n-                                 \"model or are m2m fields: %s\"\n-                                 % ', '.join(non_model_fields))\n-\n-        # If saving to the same database, and this model is deferred, then\n-        # automatically do an \"update_fields\" save on the loaded fields.\n-        elif not force_insert and deferred_fields and using == self._state.db:\n-            field_names = set()\n-            for field in self._meta.concrete_fields:\n-                if not field.primary_key and not hasattr(field, 'through'):\n-                    field_names.add(field.attname)\n-            loaded_fields = field_names.difference(deferred_fields)\n-            if loaded_fields:\n-                update_fields = frozenset(loaded_fields)\n-\n-        self.save_base(using=using, force_insert=force_insert,\n-                       force_update=force_update, update_fields=update_fields)\n-    save.alters_data = True\n-\n-    def save_base(self, raw=False, force_insert=False,\n-                  force_update=False, using=None, update_fields=None):\n-        \"\"\"\n-        Handle the parts of saving which should be done only once per save,\n-        yet need to be done in raw saves, too. This includes some sanity\n-        checks and signal sending.\n-\n-        The 'raw' argument is telling save_base not to save any parent\n-        models and not to do any changes to the values before save. This\n-        is used by fixture loading.\n-        \"\"\"\n-        using = using or router.db_for_write(self.__class__, instance=self)\n-        assert not (force_insert and (force_update or update_fields))\n-        assert update_fields is None or update_fields\n-        cls = origin = self.__class__\n-        # Skip proxies, but keep the origin as the proxy model.\n-        if cls._meta.proxy:\n-            cls = cls._meta.concrete_model\n-        meta = cls._meta\n-        if not meta.auto_created:\n-            pre_save.send(\n-                sender=origin, instance=self, raw=raw, using=using,\n-                update_fields=update_fields,\n-            )\n-        # A transaction isn't needed if one query is issued.\n-        if meta.parents:\n-            context_manager = transaction.atomic(using=using, savepoint=False)\n-        else:\n-            context_manager = transaction.mark_for_rollback_on_error(using=using)\n-        with context_manager:\n-            parent_inserted = False\n-            if not raw:\n-                parent_inserted = self._save_parents(cls, using, update_fields)\n-            updated = self._save_table(\n-                raw, cls, force_insert or parent_inserted,\n-                force_update, using, update_fields,\n-            )\n-        # Store the database on which the object was saved\n-        self._state.db = using\n-        # Once saved, this is no longer a to-be-added instance.\n-        self._state.adding = False\n-\n-        # Signal that the save is complete\n-        if not meta.auto_created:\n-            post_save.send(\n-                sender=origin, instance=self, created=(not updated),\n-                update_fields=update_fields, raw=raw, using=using,\n-            )\n-\n-    save_base.alters_data = True\n-\n-    def _save_parents(self, cls, using, update_fields):\n-        \"\"\"Save all the parents of cls using values from self.\"\"\"\n-        meta = cls._meta\n-        inserted = False\n-        for parent, field in meta.parents.items():\n-            # Make sure the link fields are synced between parent and self.\n-            if (field and getattr(self, parent._meta.pk.attname) is None and\n-                    getattr(self, field.attname) is not None):\n-                setattr(self, parent._meta.pk.attname, getattr(self, field.attname))\n-            parent_inserted = self._save_parents(cls=parent, using=using, update_fields=update_fields)\n-            updated = self._save_table(\n-                cls=parent, using=using, update_fields=update_fields,\n-                force_insert=parent_inserted,\n-            )\n-            if not updated:\n-                inserted = True\n-            # Set the parent's PK value to self.\n-            if field:\n-                setattr(self, field.attname, self._get_pk_val(parent._meta))\n-                # Since we didn't have an instance of the parent handy set\n-                # attname directly, bypassing the descriptor. Invalidate\n-                # the related object cache, in case it's been accidentally\n-                # populated. A fresh instance will be re-built from the\n-                # database if necessary.\n-                if field.is_cached(self):\n-                    field.delete_cached_value(self)\n-        return inserted\n-\n-    def _save_table(self, raw=False, cls=None, force_insert=False,\n-                    force_update=False, using=None, update_fields=None):\n-        \"\"\"\n-        Do the heavy-lifting involved in saving. Update or insert the data\n-        for a single table.\n-        \"\"\"\n-        meta = cls._meta\n-        non_pks = [f for f in meta.local_concrete_fields if not f.primary_key]\n-\n-        if update_fields:\n-            non_pks = [f for f in non_pks\n-                       if f.name in update_fields or f.attname in update_fields]\n-\n-        pk_val = self._get_pk_val(meta)\n-        if pk_val is None:\n-            pk_val = meta.pk.get_pk_value_on_save(self)\n-            setattr(self, meta.pk.attname, pk_val)\n-        pk_set = pk_val is not None\n-        if not pk_set and (force_update or update_fields):\n-            raise ValueError(\"Cannot force an update in save() with no primary key.\")\n-        updated = False\n-        # Skip an UPDATE when adding an instance and primary key has a default.\n-        if (\n-            not force_insert and\n-            self._state.adding and\n-            self._meta.pk.default and\n-            self._meta.pk.default is not NOT_PROVIDED\n-        ):\n-            force_insert = True\n-        # If possible, try an UPDATE. If that doesn't update anything, do an INSERT.\n-        if pk_set and not force_insert:\n-            base_qs = cls._base_manager.using(using)\n-            values = [(f, None, (getattr(self, f.attname) if raw else f.pre_save(self, False)))\n-                      for f in non_pks]\n-            forced_update = update_fields or force_update\n-            updated = self._do_update(base_qs, using, pk_val, values, update_fields,\n-                                      forced_update)\n-            if force_update and not updated:\n-                raise DatabaseError(\"Forced update did not affect any rows.\")\n-            if update_fields and not updated:\n-                raise DatabaseError(\"Save with update_fields did not affect any rows.\")\n-        if not updated:\n-            if meta.order_with_respect_to:\n-                # If this is a model with an order_with_respect_to\n-                # autopopulate the _order field\n-                field = meta.order_with_respect_to\n-                filter_args = field.get_filter_kwargs_for_object(self)\n-                self._order = cls._base_manager.using(using).filter(**filter_args).aggregate(\n-                    _order__max=Coalesce(\n-                        ExpressionWrapper(Max('_order') + Value(1), output_field=IntegerField()),\n-                        Value(0),\n-                    ),\n-                )['_order__max']\n-            fields = meta.local_concrete_fields\n-            if not pk_set:\n-                fields = [f for f in fields if f is not meta.auto_field]\n-\n-            returning_fields = meta.db_returning_fields\n-            results = self._do_insert(cls._base_manager, using, fields, returning_fields, raw)\n-            for result, field in zip(results, returning_fields):\n-                setattr(self, field.attname, result)\n-        return updated\n-\n-    def _do_update(self, base_qs, using, pk_val, values, update_fields, forced_update):\n-        \"\"\"\n-        Try to update the model. Return True if the model was updated (if an\n-        update query was done and a matching row was found in the DB).\n-        \"\"\"\n-        filtered = base_qs.filter(pk=pk_val)\n-        if not values:\n-            # We can end up here when saving a model in inheritance chain where\n-            # update_fields doesn't target any field in current model. In that\n-            # case we just say the update succeeded. Another case ending up here\n-            # is a model with just PK - in that case check that the PK still\n-            # exists.\n-            return update_fields is not None or filtered.exists()\n-        if self._meta.select_on_save and not forced_update:\n-            return (\n-                filtered.exists() and\n-                # It may happen that the object is deleted from the DB right after\n-                # this check, causing the subsequent UPDATE to return zero matching\n-                # rows. The same result can occur in some rare cases when the\n-                # database returns zero despite the UPDATE being executed\n-                # successfully (a row is matched and updated). In order to\n-                # distinguish these two cases, the object's existence in the\n-                # database is again checked for if the UPDATE query returns 0.\n-                (filtered._update(values) > 0 or filtered.exists())\n-            )\n-        return filtered._update(values) > 0\n-\n-    def _do_insert(self, manager, using, fields, returning_fields, raw):\n-        \"\"\"\n-        Do an INSERT. If returning_fields is defined then this method should\n-        return the newly created data for the model.\n-        \"\"\"\n-        return manager._insert(\n-            [self], fields=fields, returning_fields=returning_fields,\n-            using=using, raw=raw,\n-        )\n-\n-    def delete(self, using=None, keep_parents=False):\n-        using = using or router.db_for_write(self.__class__, instance=self)\n-        assert self.pk is not None, (\n-            \"%s object can't be deleted because its %s attribute is set to None.\" %\n-            (self._meta.object_name, self._meta.pk.attname)\n-        )\n-\n-        collector = Collector(using=using)\n-        collector.collect([self], keep_parents=keep_parents)\n-        return collector.delete()\n-\n-    delete.alters_data = True\n-\n-    def _get_FIELD_display(self, field):\n-        value = getattr(self, field.attname)\n-        # force_str() to coerce lazy strings.\n-        return force_str(dict(field.flatchoices).get(value, value), strings_only=True)\n-\n-    def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs):\n-        if not self.pk:\n-            raise ValueError(\"get_next/get_previous cannot be used on unsaved objects.\")\n-        op = 'gt' if is_next else 'lt'\n-        order = '' if is_next else '-'\n-        param = getattr(self, field.attname)\n-        q = Q(**{'%s__%s' % (field.name, op): param})\n-        q = q | Q(**{field.name: param, 'pk__%s' % op: self.pk})\n-        qs = self.__class__._default_manager.using(self._state.db).filter(**kwargs).filter(q).order_by(\n-            '%s%s' % (order, field.name), '%spk' % order\n-        )\n-        try:\n-            return qs[0]\n-        except IndexError:\n-            raise self.DoesNotExist(\"%s matching query does not exist.\" % self.__class__._meta.object_name)\n-\n-    def _get_next_or_previous_in_order(self, is_next):\n-        cachename = \"__%s_order_cache\" % is_next\n-        if not hasattr(self, cachename):\n-            op = 'gt' if is_next else 'lt'\n-            order = '_order' if is_next else '-_order'\n-            order_field = self._meta.order_with_respect_to\n-            filter_args = order_field.get_filter_kwargs_for_object(self)\n-            obj = self.__class__._default_manager.filter(**filter_args).filter(**{\n-                '_order__%s' % op: self.__class__._default_manager.values('_order').filter(**{\n-                    self._meta.pk.name: self.pk\n-                })\n-            }).order_by(order)[:1].get()\n-            setattr(self, cachename, obj)\n-        return getattr(self, cachename)\n-\n-    def prepare_database_save(self, field):\n-        if self.pk is None:\n-            raise ValueError(\"Unsaved model instance %r cannot be used in an ORM query.\" % self)\n-        return getattr(self, field.remote_field.get_related_field().attname)\n-\n-    def clean(self):\n-        \"\"\"\n-        Hook for doing any extra model-wide validation after clean() has been\n-        called on every field by self.clean_fields. Any ValidationError raised\n-        by this method will not be associated with a particular field; it will\n-        have a special-case association with the field defined by NON_FIELD_ERRORS.\n-        \"\"\"\n-        pass\n-\n-    def validate_unique(self, exclude=None):\n-        \"\"\"\n-        Check unique constraints on the model and raise ValidationError if any\n-        failed.\n-        \"\"\"\n-        unique_checks, date_checks = self._get_unique_checks(exclude=exclude)\n-\n-        errors = self._perform_unique_checks(unique_checks)\n-        date_errors = self._perform_date_checks(date_checks)\n-\n-        for k, v in date_errors.items():\n-            errors.setdefault(k, []).extend(v)\n-\n-        if errors:\n-            raise ValidationError(errors)\n-\n-    def _get_unique_checks(self, exclude=None):\n-        \"\"\"\n-        Return a list of checks to perform. Since validate_unique() could be\n-        called from a ModelForm, some fields may have been excluded; we can't\n-        perform a unique check on a model that is missing fields involved\n-        in that check. Fields that did not validate should also be excluded,\n-        but they need to be passed in via the exclude argument.\n-        \"\"\"\n-        if exclude is None:\n-            exclude = []\n-        unique_checks = []\n-\n-        unique_togethers = [(self.__class__, self._meta.unique_together)]\n-        constraints = [(self.__class__, self._meta.constraints)]\n-        for parent_class in self._meta.get_parent_list():\n-            if parent_class._meta.unique_together:\n-                unique_togethers.append((parent_class, parent_class._meta.unique_together))\n-            if parent_class._meta.constraints:\n-                constraints.append((parent_class, parent_class._meta.constraints))\n-\n-        for model_class, unique_together in unique_togethers:\n-            for check in unique_together:\n-                if not any(name in exclude for name in check):\n-                    # Add the check if the field isn't excluded.\n-                    unique_checks.append((model_class, tuple(check)))\n-\n-        for model_class, model_constraints in constraints:\n-            for constraint in model_constraints:\n-                if (isinstance(constraint, UniqueConstraint) and\n-                        # Partial unique constraints can't be validated.\n-                        constraint.condition is None and\n-                        not any(name in exclude for name in constraint.fields)):\n-                    unique_checks.append((model_class, constraint.fields))\n-\n-        # These are checks for the unique_for_<date/year/month>.\n-        date_checks = []\n-\n-        # Gather a list of checks for fields declared as unique and add them to\n-        # the list of checks.\n-\n-        fields_with_class = [(self.__class__, self._meta.local_fields)]\n-        for parent_class in self._meta.get_parent_list():\n-            fields_with_class.append((parent_class, parent_class._meta.local_fields))\n-\n-        for model_class, fields in fields_with_class:\n-            for f in fields:\n-                name = f.name\n-                if name in exclude:\n-                    continue\n-                if f.unique:\n-                    unique_checks.append((model_class, (name,)))\n-                if f.unique_for_date and f.unique_for_date not in exclude:\n-                    date_checks.append((model_class, 'date', name, f.unique_for_date))\n-                if f.unique_for_year and f.unique_for_year not in exclude:\n-                    date_checks.append((model_class, 'year', name, f.unique_for_year))\n-                if f.unique_for_month and f.unique_for_month not in exclude:\n-                    date_checks.append((model_class, 'month', name, f.unique_for_month))\n-        return unique_checks, date_checks\n-\n-    def _perform_unique_checks(self, unique_checks):\n-        errors = {}\n-\n-        for model_class, unique_check in unique_checks:\n-            # Try to look up an existing object with the same values as this\n-            # object's values for all the unique field.\n-\n-            lookup_kwargs = {}\n-            for field_name in unique_check:\n-                f = self._meta.get_field(field_name)\n-                lookup_value = getattr(self, f.attname)\n-                # TODO: Handle multiple backends with different feature flags.\n-                if (lookup_value is None or\n-                        (lookup_value == '' and connection.features.interprets_empty_strings_as_nulls)):\n-                    # no value, skip the lookup\n-                    continue\n-                if f.primary_key and not self._state.adding:\n-                    # no need to check for unique primary key when editing\n-                    continue\n-                lookup_kwargs[str(field_name)] = lookup_value\n-\n-            # some fields were skipped, no reason to do the check\n-            if len(unique_check) != len(lookup_kwargs):\n-                continue\n-\n-            qs = model_class._default_manager.filter(**lookup_kwargs)\n-\n-            # Exclude the current object from the query if we are editing an\n-            # instance (as opposed to creating a new one)\n-            # Note that we need to use the pk as defined by model_class, not\n-            # self.pk. These can be different fields because model inheritance\n-            # allows single model to have effectively multiple primary keys.\n-            # Refs #17615.\n-            model_class_pk = self._get_pk_val(model_class._meta)\n-            if not self._state.adding and model_class_pk is not None:\n-                qs = qs.exclude(pk=model_class_pk)\n-            if qs.exists():\n-                if len(unique_check) == 1:\n-                    key = unique_check[0]\n-                else:\n-                    key = NON_FIELD_ERRORS\n-                errors.setdefault(key, []).append(self.unique_error_message(model_class, unique_check))\n-\n-        return errors\n-\n-    def _perform_date_checks(self, date_checks):\n-        errors = {}\n-        for model_class, lookup_type, field, unique_for in date_checks:\n-            lookup_kwargs = {}\n-            # there's a ticket to add a date lookup, we can remove this special\n-            # case if that makes it's way in\n-            date = getattr(self, unique_for)\n-            if date is None:\n-                continue\n-            if lookup_type == 'date':\n-                lookup_kwargs['%s__day' % unique_for] = date.day\n-                lookup_kwargs['%s__month' % unique_for] = date.month\n-                lookup_kwargs['%s__year' % unique_for] = date.year\n-            else:\n-                lookup_kwargs['%s__%s' % (unique_for, lookup_type)] = getattr(date, lookup_type)\n-            lookup_kwargs[field] = getattr(self, field)\n-\n-            qs = model_class._default_manager.filter(**lookup_kwargs)\n-            # Exclude the current object from the query if we are editing an\n-            # instance (as opposed to creating a new one)\n-            if not self._state.adding and self.pk is not None:\n-                qs = qs.exclude(pk=self.pk)\n-\n-            if qs.exists():\n-                errors.setdefault(field, []).append(\n-                    self.date_error_message(lookup_type, field, unique_for)\n-                )\n-        return errors\n-\n-    def date_error_message(self, lookup_type, field_name, unique_for):\n-        opts = self._meta\n-        field = opts.get_field(field_name)\n-        return ValidationError(\n-            message=field.error_messages['unique_for_date'],\n-            code='unique_for_date',\n-            params={\n-                'model': self,\n-                'model_name': capfirst(opts.verbose_name),\n-                'lookup_type': lookup_type,\n-                'field': field_name,\n-                'field_label': capfirst(field.verbose_name),\n-                'date_field': unique_for,\n-                'date_field_label': capfirst(opts.get_field(unique_for).verbose_name),\n-            }\n-        )\n-\n-    def unique_error_message(self, model_class, unique_check):\n-        opts = model_class._meta\n-\n-        params = {\n-            'model': self,\n-            'model_class': model_class,\n-            'model_name': capfirst(opts.verbose_name),\n-            'unique_check': unique_check,\n-        }\n-\n-        # A unique field\n-        if len(unique_check) == 1:\n-            field = opts.get_field(unique_check[0])\n-            params['field_label'] = capfirst(field.verbose_name)\n-            return ValidationError(\n-                message=field.error_messages['unique'],\n-                code='unique',\n-                params=params,\n-            )\n-\n-        # unique_together\n-        else:\n-            field_labels = [capfirst(opts.get_field(f).verbose_name) for f in unique_check]\n-            params['field_labels'] = get_text_list(field_labels, _('and'))\n-            return ValidationError(\n-                message=_(\"%(model_name)s with this %(field_labels)s already exists.\"),\n-                code='unique_together',\n-                params=params,\n-            )\n-\n-    def full_clean(self, exclude=None, validate_unique=True):\n-        \"\"\"\n-        Call clean_fields(), clean(), and validate_unique() on the model.\n-        Raise a ValidationError for any errors that occur.\n-        \"\"\"\n-        errors = {}\n-        if exclude is None:\n-            exclude = []\n-        else:\n-            exclude = list(exclude)\n-\n-        try:\n-            self.clean_fields(exclude=exclude)\n-        except ValidationError as e:\n-            errors = e.update_error_dict(errors)\n-\n-        # Form.clean() is run even if other validation fails, so do the\n-        # same with Model.clean() for consistency.\n-        try:\n-            self.clean()\n-        except ValidationError as e:\n-            errors = e.update_error_dict(errors)\n-\n-        # Run unique checks, but only for fields that passed validation.\n-        if validate_unique:\n-            for name in errors:\n-                if name != NON_FIELD_ERRORS and name not in exclude:\n-                    exclude.append(name)\n-            try:\n-                self.validate_unique(exclude=exclude)\n-            except ValidationError as e:\n-                errors = e.update_error_dict(errors)\n-\n-        if errors:\n-            raise ValidationError(errors)\n-\n-    def clean_fields(self, exclude=None):\n-        \"\"\"\n-        Clean all fields and raise a ValidationError containing a dict\n-        of all validation errors if any occur.\n-        \"\"\"\n-        if exclude is None:\n-            exclude = []\n-\n-        errors = {}\n-        for f in self._meta.fields:\n-            if f.name in exclude:\n-                continue\n-            # Skip validation for empty fields with blank=True. The developer\n-            # is responsible for making sure they have a valid value.\n-            raw_value = getattr(self, f.attname)\n-            if f.blank and raw_value in f.empty_values:\n-                continue\n-            try:\n-                setattr(self, f.attname, f.clean(raw_value, self))\n-            except ValidationError as e:\n-                errors[f.name] = e.error_list\n-\n-        if errors:\n-            raise ValidationError(errors)\n-\n-    @classmethod\n-    def check(cls, **kwargs):\n-        errors = [*cls._check_swappable(), *cls._check_model(), *cls._check_managers(**kwargs)]\n-        if not cls._meta.swapped:\n-            errors += [\n-                *cls._check_fields(**kwargs),\n-                *cls._check_m2m_through_same_relationship(),\n-                *cls._check_long_column_names(),\n-            ]\n-            clash_errors = (\n-                *cls._check_id_field(),\n-                *cls._check_field_name_clashes(),\n-                *cls._check_model_name_db_lookup_clashes(),\n-                *cls._check_property_name_related_field_accessor_clashes(),\n-                *cls._check_single_primary_key(),\n-            )\n-            errors.extend(clash_errors)\n-            # If there are field name clashes, hide consequent column name\n-            # clashes.\n-            if not clash_errors:\n-                errors.extend(cls._check_column_name_clashes())\n-            errors += [\n-                *cls._check_index_together(),\n-                *cls._check_unique_together(),\n-                *cls._check_indexes(),\n-                *cls._check_ordering(),\n-                *cls._check_constraints(),\n-            ]\n-\n-        return errors\n-\n-    @classmethod\n-    def _check_swappable(cls):\n-        \"\"\"Check if the swapped model exists.\"\"\"\n-        errors = []\n-        if cls._meta.swapped:\n-            try:\n-                apps.get_model(cls._meta.swapped)\n-            except ValueError:\n-                errors.append(\n-                    checks.Error(\n-                        \"'%s' is not of the form 'app_label.app_name'.\" % cls._meta.swappable,\n-                        id='models.E001',\n-                    )\n-                )\n-            except LookupError:\n-                app_label, model_name = cls._meta.swapped.split('.')\n-                errors.append(\n-                    checks.Error(\n-                        \"'%s' references '%s.%s', which has not been \"\n-                        \"installed, or is abstract.\" % (\n-                            cls._meta.swappable, app_label, model_name\n-                        ),\n-                        id='models.E002',\n-                    )\n-                )\n-        return errors\n-\n-    @classmethod\n-    def _check_model(cls):\n-        errors = []\n-        if cls._meta.proxy:\n-            if cls._meta.local_fields or cls._meta.local_many_to_many:\n-                errors.append(\n-                    checks.Error(\n-                        \"Proxy model '%s' contains model fields.\" % cls.__name__,\n-                        id='models.E017',\n-                    )\n-                )\n-        return errors\n-\n-    @classmethod\n-    def _check_managers(cls, **kwargs):\n-        \"\"\"Perform all manager checks.\"\"\"\n-        errors = []\n-        for manager in cls._meta.managers:\n-            errors.extend(manager.check(**kwargs))\n-        return errors\n-\n-    @classmethod\n-    def _check_fields(cls, **kwargs):\n-        \"\"\"Perform all field checks.\"\"\"\n-        errors = []\n-        for field in cls._meta.local_fields:\n-            errors.extend(field.check(**kwargs))\n-        for field in cls._meta.local_many_to_many:\n-            errors.extend(field.check(from_model=cls, **kwargs))\n-        return errors\n-\n-    @classmethod\n-    def _check_m2m_through_same_relationship(cls):\n-        \"\"\" Check if no relationship model is used by more than one m2m field.\n-        \"\"\"\n-\n-        errors = []\n-        seen_intermediary_signatures = []\n-\n-        fields = cls._meta.local_many_to_many\n-\n-        # Skip when the target model wasn't found.\n-        fields = (f for f in fields if isinstance(f.remote_field.model, ModelBase))\n-\n-        # Skip when the relationship model wasn't found.\n-        fields = (f for f in fields if isinstance(f.remote_field.through, ModelBase))\n-\n-        for f in fields:\n-            signature = (f.remote_field.model, cls, f.remote_field.through, f.remote_field.through_fields)\n-            if signature in seen_intermediary_signatures:\n-                errors.append(\n-                    checks.Error(\n-                        \"The model has two identical many-to-many relations \"\n-                        \"through the intermediate model '%s'.\" %\n-                        f.remote_field.through._meta.label,\n-                        obj=cls,\n-                        id='models.E003',\n-                    )\n-                )\n-            else:\n-                seen_intermediary_signatures.append(signature)\n-        return errors\n-\n-    @classmethod\n-    def _check_id_field(cls):\n-        \"\"\"Check if `id` field is a primary key.\"\"\"\n-        fields = [f for f in cls._meta.local_fields if f.name == 'id' and f != cls._meta.pk]\n-        # fields is empty or consists of the invalid \"id\" field\n-        if fields and not fields[0].primary_key and cls._meta.pk.name == 'id':\n-            return [\n-                checks.Error(\n-                    \"'id' can only be used as a field name if the field also \"\n-                    \"sets 'primary_key=True'.\",\n-                    obj=cls,\n-                    id='models.E004',\n-                )\n-            ]\n-        else:\n-            return []\n-\n-    @classmethod\n-    def _check_field_name_clashes(cls):\n-        \"\"\"Forbid field shadowing in multi-table inheritance.\"\"\"\n-        errors = []\n-        used_fields = {}  # name or attname -> field\n-\n-        # Check that multi-inheritance doesn't cause field name shadowing.\n-        for parent in cls._meta.get_parent_list():\n-            for f in parent._meta.local_fields:\n-                clash = used_fields.get(f.name) or used_fields.get(f.attname) or None\n-                if clash:\n-                    errors.append(\n-                        checks.Error(\n-                            \"The field '%s' from parent model \"\n-                            \"'%s' clashes with the field '%s' \"\n-                            \"from parent model '%s'.\" % (\n-                                clash.name, clash.model._meta,\n-                                f.name, f.model._meta\n-                            ),\n-                            obj=cls,\n-                            id='models.E005',\n-                        )\n-                    )\n-                used_fields[f.name] = f\n-                used_fields[f.attname] = f\n-\n-        # Check that fields defined in the model don't clash with fields from\n-        # parents, including auto-generated fields like multi-table inheritance\n-        # child accessors.\n-        for parent in cls._meta.get_parent_list():\n-            for f in parent._meta.get_fields():\n-                if f not in used_fields:\n-                    used_fields[f.name] = f\n-\n-        for f in cls._meta.local_fields:\n-            clash = used_fields.get(f.name) or used_fields.get(f.attname) or None\n-            # Note that we may detect clash between user-defined non-unique\n-            # field \"id\" and automatically added unique field \"id\", both\n-            # defined at the same model. This special case is considered in\n-            # _check_id_field and here we ignore it.\n-            id_conflict = f.name == \"id\" and clash and clash.name == \"id\" and clash.model == cls\n-            if clash and not id_conflict:\n-                errors.append(\n-                    checks.Error(\n-                        \"The field '%s' clashes with the field '%s' \"\n-                        \"from model '%s'.\" % (\n-                            f.name, clash.name, clash.model._meta\n-                        ),\n-                        obj=f,\n-                        id='models.E006',\n-                    )\n-                )\n-            used_fields[f.name] = f\n-            used_fields[f.attname] = f\n-\n-        return errors\n-\n-    @classmethod\n-    def _check_column_name_clashes(cls):\n-        # Store a list of column names which have already been used by other fields.\n-        used_column_names = []\n-        errors = []\n-\n-        for f in cls._meta.local_fields:\n-            _, column_name = f.get_attname_column()\n-\n-            # Ensure the column name is not already in use.\n-            if column_name and column_name in used_column_names:\n-                errors.append(\n-                    checks.Error(\n-                        \"Field '%s' has column name '%s' that is used by \"\n-                        \"another field.\" % (f.name, column_name),\n-                        hint=\"Specify a 'db_column' for the field.\",\n-                        obj=cls,\n-                        id='models.E007'\n-                    )\n-                )\n-            else:\n-                used_column_names.append(column_name)\n-\n-        return errors\n-\n-    @classmethod\n-    def _check_model_name_db_lookup_clashes(cls):\n-        errors = []\n-        model_name = cls.__name__\n-        if model_name.startswith('_') or model_name.endswith('_'):\n-            errors.append(\n-                checks.Error(\n-                    \"The model name '%s' cannot start or end with an underscore \"\n-                    \"as it collides with the query lookup syntax.\" % model_name,\n-                    obj=cls,\n-                    id='models.E023'\n-                )\n-            )\n-        elif LOOKUP_SEP in model_name:\n-            errors.append(\n-                checks.Error(\n-                    \"The model name '%s' cannot contain double underscores as \"\n-                    \"it collides with the query lookup syntax.\" % model_name,\n-                    obj=cls,\n-                    id='models.E024'\n-                )\n-            )\n-        return errors\n-\n-    @classmethod\n-    def _check_property_name_related_field_accessor_clashes(cls):\n-        errors = []\n-        property_names = cls._meta._property_names\n-        related_field_accessors = (\n-            f.get_attname() for f in cls._meta._get_fields(reverse=False)\n-            if f.is_relation and f.related_model is not None\n-        )\n-        for accessor in related_field_accessors:\n-            if accessor in property_names:\n-                errors.append(\n-                    checks.Error(\n-                        \"The property '%s' clashes with a related field \"\n-                        \"accessor.\" % accessor,\n-                        obj=cls,\n-                        id='models.E025',\n-                    )\n-                )\n-        return errors\n-\n-    @classmethod\n-    def _check_single_primary_key(cls):\n-        errors = []\n-        if sum(1 for f in cls._meta.local_fields if f.primary_key) > 1:\n-            errors.append(\n-                checks.Error(\n-                    \"The model cannot have more than one field with \"\n-                    \"'primary_key=True'.\",\n-                    obj=cls,\n-                    id='models.E026',\n-                )\n-            )\n-        return errors\n-\n-    @classmethod\n-    def _check_index_together(cls):\n-        \"\"\"Check the value of \"index_together\" option.\"\"\"\n-        if not isinstance(cls._meta.index_together, (tuple, list)):\n-            return [\n-                checks.Error(\n-                    \"'index_together' must be a list or tuple.\",\n-                    obj=cls,\n-                    id='models.E008',\n-                )\n-            ]\n-\n-        elif any(not isinstance(fields, (tuple, list)) for fields in cls._meta.index_together):\n-            return [\n-                checks.Error(\n-                    \"All 'index_together' elements must be lists or tuples.\",\n-                    obj=cls,\n-                    id='models.E009',\n-                )\n-            ]\n-\n-        else:\n-            errors = []\n-            for fields in cls._meta.index_together:\n-                errors.extend(cls._check_local_fields(fields, \"index_together\"))\n-            return errors\n-\n-    @classmethod\n-    def _check_unique_together(cls):\n-        \"\"\"Check the value of \"unique_together\" option.\"\"\"\n-        if not isinstance(cls._meta.unique_together, (tuple, list)):\n-            return [\n-                checks.Error(\n-                    \"'unique_together' must be a list or tuple.\",\n-                    obj=cls,\n-                    id='models.E010',\n-                )\n-            ]\n-\n-        elif any(not isinstance(fields, (tuple, list)) for fields in cls._meta.unique_together):\n-            return [\n-                checks.Error(\n-                    \"All 'unique_together' elements must be lists or tuples.\",\n-                    obj=cls,\n-                    id='models.E011',\n-                )\n-            ]\n-\n-        else:\n-            errors = []\n-            for fields in cls._meta.unique_together:\n-                errors.extend(cls._check_local_fields(fields, \"unique_together\"))\n-            return errors\n-\n-    @classmethod\n-    def _check_indexes(cls):\n-        \"\"\"Check the fields and names of indexes.\"\"\"\n-        errors = []\n-        for index in cls._meta.indexes:\n-            # Index name can't start with an underscore or a number, restricted\n-            # for cross-database compatibility with Oracle.\n-            if index.name[0] == '_' or index.name[0].isdigit():\n-                errors.append(\n-                    checks.Error(\n-                        \"The index name '%s' cannot start with an underscore \"\n-                        \"or a number.\" % index.name,\n-                        obj=cls,\n-                        id='models.E033',\n-                    ),\n-                )\n-            if len(index.name) > index.max_name_length:\n-                errors.append(\n-                    checks.Error(\n-                        \"The index name '%s' cannot be longer than %d \"\n-                        \"characters.\" % (index.name, index.max_name_length),\n-                        obj=cls,\n-                        id='models.E034',\n-                    ),\n-                )\n-        fields = [field for index in cls._meta.indexes for field, _ in index.fields_orders]\n-        errors.extend(cls._check_local_fields(fields, 'indexes'))\n-        return errors\n-\n-    @classmethod\n-    def _check_local_fields(cls, fields, option):\n-        from django.db import models\n-\n-        # In order to avoid hitting the relation tree prematurely, we use our\n-        # own fields_map instead of using get_field()\n-        forward_fields_map = {}\n-        for field in cls._meta._get_fields(reverse=False):\n-            forward_fields_map[field.name] = field\n-            if hasattr(field, 'attname'):\n-                forward_fields_map[field.attname] = field\n-\n-        errors = []\n-        for field_name in fields:\n-            try:\n-                field = forward_fields_map[field_name]\n-            except KeyError:\n-                errors.append(\n-                    checks.Error(\n-                        \"'%s' refers to the nonexistent field '%s'.\" % (\n-                            option, field_name,\n-                        ),\n-                        obj=cls,\n-                        id='models.E012',\n-                    )\n-                )\n-            else:\n-                if isinstance(field.remote_field, models.ManyToManyRel):\n-                    errors.append(\n-                        checks.Error(\n-                            \"'%s' refers to a ManyToManyField '%s', but \"\n-                            \"ManyToManyFields are not permitted in '%s'.\" % (\n-                                option, field_name, option,\n-                            ),\n-                            obj=cls,\n-                            id='models.E013',\n-                        )\n-                    )\n-                elif field not in cls._meta.local_fields:\n-                    errors.append(\n-                        checks.Error(\n-                            \"'%s' refers to field '%s' which is not local to model '%s'.\"\n-                            % (option, field_name, cls._meta.object_name),\n-                            hint=\"This issue may be caused by multi-table inheritance.\",\n-                            obj=cls,\n-                            id='models.E016',\n-                        )\n-                    )\n-        return errors\n-\n-    @classmethod\n-    def _check_ordering(cls):\n-        \"\"\"\n-        Check \"ordering\" option -- is it a list of strings and do all fields\n-        exist?\n-        \"\"\"\n-        if cls._meta._ordering_clash:\n-            return [\n-                checks.Error(\n-                    \"'ordering' and 'order_with_respect_to' cannot be used together.\",\n-                    obj=cls,\n-                    id='models.E021',\n-                ),\n-            ]\n-\n-        if cls._meta.order_with_respect_to or not cls._meta.ordering:\n-            return []\n-\n-        if not isinstance(cls._meta.ordering, (list, tuple)):\n-            return [\n-                checks.Error(\n-                    \"'ordering' must be a tuple or list (even if you want to order by only one field).\",\n-                    obj=cls,\n-                    id='models.E014',\n-                )\n-            ]\n-\n-        errors = []\n-        fields = cls._meta.ordering\n-\n-        # Skip expressions and '?' fields.\n-        fields = (f for f in fields if isinstance(f, str) and f != '?')\n-\n-        # Convert \"-field\" to \"field\".\n-        fields = ((f[1:] if f.startswith('-') else f) for f in fields)\n-\n-        # Separate related fields and non-related fields.\n-        _fields = []\n-        related_fields = []\n-        for f in fields:\n-            if LOOKUP_SEP in f:\n-                related_fields.append(f)\n-            else:\n-                _fields.append(f)\n-        fields = _fields\n-\n-        # Check related fields.\n-        for field in related_fields:\n-            _cls = cls\n-            fld = None\n-            for part in field.split(LOOKUP_SEP):\n-                try:\n-                    fld = _cls._meta.get_field(part)\n-                    if fld.is_relation:\n-                        _cls = fld.get_path_info()[-1].to_opts.model\n-                except (FieldDoesNotExist, AttributeError):\n-                    if fld is None or fld.get_transform(part) is None:\n-                        errors.append(\n-                            checks.Error(\n-                                \"'ordering' refers to the nonexistent field, \"\n-                                \"related field, or lookup '%s'.\" % field,\n-                                obj=cls,\n-                                id='models.E015',\n-                            )\n-                        )\n-\n-        # Skip ordering on pk. This is always a valid order_by field\n-        # but is an alias and therefore won't be found by opts.get_field.\n-        fields = {f for f in fields if f != 'pk'}\n-\n-        # Check for invalid or nonexistent fields in ordering.\n-        invalid_fields = []\n-\n-        # Any field name that is not present in field_names does not exist.\n-        # Also, ordering by m2m fields is not allowed.\n-        opts = cls._meta\n-        valid_fields = set(chain.from_iterable(\n-            (f.name, f.attname) if not (f.auto_created and not f.concrete) else (f.field.related_query_name(),)\n-            for f in chain(opts.fields, opts.related_objects)\n-        ))\n-\n-        invalid_fields.extend(fields - valid_fields)\n-\n-        for invalid_field in invalid_fields:\n-            errors.append(\n-                checks.Error(\n-                    \"'ordering' refers to the nonexistent field, related \"\n-                    \"field, or lookup '%s'.\" % invalid_field,\n-                    obj=cls,\n-                    id='models.E015',\n-                )\n-            )\n-        return errors\n-\n-    @classmethod\n-    def _check_long_column_names(cls):\n-        \"\"\"\n-        Check that any auto-generated column names are shorter than the limits\n-        for each database in which the model will be created.\n-        \"\"\"\n-        errors = []\n-        allowed_len = None\n-        db_alias = None\n-\n-        # Find the minimum max allowed length among all specified db_aliases.\n-        for db in settings.DATABASES:\n-            # skip databases where the model won't be created\n-            if not router.allow_migrate_model(db, cls):\n-                continue\n-            connection = connections[db]\n-            max_name_length = connection.ops.max_name_length()\n-            if max_name_length is None or connection.features.truncates_names:\n-                continue\n-            else:\n-                if allowed_len is None:\n-                    allowed_len = max_name_length\n-                    db_alias = db\n-                elif max_name_length < allowed_len:\n-                    allowed_len = max_name_length\n-                    db_alias = db\n-\n-        if allowed_len is None:\n-            return errors\n-\n-        for f in cls._meta.local_fields:\n-            _, column_name = f.get_attname_column()\n-\n-            # Check if auto-generated name for the field is too long\n-            # for the database.\n-            if f.db_column is None and column_name is not None and len(column_name) > allowed_len:\n-                errors.append(\n-                    checks.Error(\n-                        'Autogenerated column name too long for field \"%s\". '\n-                        'Maximum length is \"%s\" for database \"%s\".'\n-                        % (column_name, allowed_len, db_alias),\n-                        hint=\"Set the column name manually using 'db_column'.\",\n-                        obj=cls,\n-                        id='models.E018',\n-                    )\n-                )\n-\n-        for f in cls._meta.local_many_to_many:\n-            # Skip nonexistent models.\n-            if isinstance(f.remote_field.through, str):\n-                continue\n-\n-            # Check if auto-generated name for the M2M field is too long\n-            # for the database.\n-            for m2m in f.remote_field.through._meta.local_fields:\n-                _, rel_name = m2m.get_attname_column()\n-                if m2m.db_column is None and rel_name is not None and len(rel_name) > allowed_len:\n-                    errors.append(\n-                        checks.Error(\n-                            'Autogenerated column name too long for M2M field '\n-                            '\"%s\". Maximum length is \"%s\" for database \"%s\".'\n-                            % (rel_name, allowed_len, db_alias),\n-                            hint=(\n-                                \"Use 'through' to create a separate model for \"\n-                                \"M2M and then set column_name using 'db_column'.\"\n-                            ),\n-                            obj=cls,\n-                            id='models.E019',\n-                        )\n-                    )\n-\n-        return errors\n-\n-    @classmethod\n-    def _check_constraints(cls):\n-        errors = []\n-        for db in settings.DATABASES:\n-            if not router.allow_migrate_model(db, cls):\n-                continue\n-            connection = connections[db]\n-            if (\n-                connection.features.supports_table_check_constraints or\n-                'supports_table_check_constraints' in cls._meta.required_db_features\n-            ):\n-                continue\n-            if any(isinstance(constraint, CheckConstraint) for constraint in cls._meta.constraints):\n-                errors.append(\n-                    checks.Warning(\n-                        '%s does not support check constraints.' % connection.display_name,\n-                        hint=(\n-                            \"A constraint won't be created. Silence this \"\n-                            \"warning if you don't care about it.\"\n-                        ),\n-                        obj=cls,\n-                        id='models.W027',\n-                    )\n-                )\n-        return errors\n-\n-\n-############################################\n-# HELPER FUNCTIONS (CURRIED MODEL METHODS) #\n-############################################\n-\n-# ORDERING METHODS #########################\n-\n-def method_set_order(self, ordered_obj, id_list, using=None):\n-    if using is None:\n-        using = DEFAULT_DB_ALIAS\n-    order_wrt = ordered_obj._meta.order_with_respect_to\n-    filter_args = order_wrt.get_forward_related_filter(self)\n-    ordered_obj.objects.db_manager(using).filter(**filter_args).bulk_update([\n-        ordered_obj(pk=pk, _order=order) for order, pk in enumerate(id_list)\n-    ], ['_order'])\n-\n-\n-def method_get_order(self, ordered_obj):\n-    order_wrt = ordered_obj._meta.order_with_respect_to\n-    filter_args = order_wrt.get_forward_related_filter(self)\n-    pk_name = ordered_obj._meta.pk.name\n-    return ordered_obj.objects.filter(**filter_args).values_list(pk_name, flat=True)\n-\n-\n-def make_foreign_order_accessors(model, related_model):\n-    setattr(\n-        related_model,\n-        'get_%s_order' % model.__name__.lower(),\n-        partialmethod(method_get_order, model)\n-    )\n-    setattr(\n-        related_model,\n-        'set_%s_order' % model.__name__.lower(),\n-        partialmethod(method_set_order, model)\n-    )\n-\n-########\n-# MISC #\n-########\n-\n-\n-def model_unpickle(model_id):\n-    \"\"\"Used to unpickle Model subclasses with deferred fields.\"\"\"\n-    if isinstance(model_id, tuple):\n-        model = apps.get_model(*model_id)\n-    else:\n-        # Backwards compat - the model was cached directly in earlier versions.\n-        model = model_id\n-    return model.__new__(model)\n-\n-\n-model_unpickle.__safe_for_unpickle__ = True\n+PLACEHOLDER\n\\ No newline at end of file\n", "model": "claude-haiku-5-5", "steps": 9, "finished": true, "patch_lines": 1910, "candidates": [{"compile_ok": 0, "loc_hits": 1, "files": 1, "diff_lines": 1910, "steps": 9}], "ms": 59121}
{"instance_id": "django__django-11848", "model_name_or_path": "cain-70b-e124", "model_patch": "diff --git a/django/utils/http.py b/django/utils/http.py\nindex 572cfb4347..c25e397d9a 100644\n--- a/django/utils/http.py\n+++ b/django/utils/http.py\n@@ -1,474 +1,8 @@\n-import base64\n-import calendar\n-import datetime\n-import re\n-import unicodedata\n-import warnings\n-from binascii import Error as BinasciiError\n-from email.utils import formatdate\n-from urllib.parse import (\n-    ParseResult, SplitResult, _coerce_args, _splitnetloc, _splitparams, quote,\n-    quote_plus, scheme_chars, unquote, unquote_plus,\n-    urlencode as original_urlencode, uses_params,\n-)\n-\n-from django.core.exceptions import TooManyFieldsSent\n-from django.utils.datastructures import MultiValueDict\n-from django.utils.deprecation import RemovedInDjango40Warning\n-from django.utils.functional import keep_lazy_text\n-\n-# based on RFC 7232, Appendix C\n-ETAG_MATCH = re.compile(r'''\n-    \\A(      # start of string and capture group\n-    (?:W/)?  # optional weak indicator\n-    \"        # opening quote\n-    [^\"]*    # any sequence of non-quote characters\n-    \"        # end quote\n-    )\\Z      # end of string and capture group\n-''', re.X)\n-\n-MONTHS = 'jan feb mar apr may jun jul aug sep oct nov dec'.split()\n-__D = r'(?P<day>\\d{2})'\n-__D2 = r'(?P<day>[ \\d]\\d)'\n-__M = r'(?P<mon>\\w{3})'\n-__Y = r'(?P<year>\\d{4})'\n-__Y2 = r'(?P<year>\\d{2})'\n-__T = r'(?P<hour>\\d{2}):(?P<min>\\d{2}):(?P<sec>\\d{2})'\n-RFC1123_DATE = re.compile(r'^\\w{3}, %s %s %s %s GMT$' % (__D, __M, __Y, __T))\n-RFC850_DATE = re.compile(r'^\\w{6,9}, %s-%s-%s %s GMT$' % (__D, __M, __Y2, __T))\n-ASCTIME_DATE = re.compile(r'^\\w{3} %s %s %s %s$' % (__M, __D2, __T, __Y))\n-\n-RFC3986_GENDELIMS = \":/?#[]@\"\n-RFC3986_SUBDELIMS = \"!$&'()*+,;=\"\n-\n-FIELDS_MATCH = re.compile('[&;]')\n-\n-\n-@keep_lazy_text\n-def urlquote(url, safe='/'):\n-    \"\"\"\n-    A legacy compatibility wrapper to Python's urllib.parse.quote() function.\n-    (was used for unicode handling on Python 2)\n-    \"\"\"\n-    warnings.warn(\n-        'django.utils.http.urlquote() is deprecated in favor of '\n-        'urllib.parse.quote().',\n-        RemovedInDjango40Warning, stacklevel=2,\n-    )\n-    return quote(url, safe)\n-\n-\n-@keep_lazy_text\n-def urlquote_plus(url, safe=''):\n-    \"\"\"\n-    A legacy compatibility wrapper to Python's urllib.parse.quote_plus()\n-    function. (was used for unicode handling on Python 2)\n-    \"\"\"\n-    warnings.warn(\n-        'django.utils.http.urlquote_plus() is deprecated in favor of '\n-        'urllib.parse.quote_plus(),',\n-        RemovedInDjango40Warning, stacklevel=2,\n-    )\n-    return quote_plus(url, safe)\n-\n-\n-@keep_lazy_text\n-def urlunquote(quoted_url):\n-    \"\"\"\n-    A legacy compatibility wrapper to Python's urllib.parse.unquote() function.\n-    (was used for unicode handling on Python 2)\n-    \"\"\"\n-    warnings.warn(\n-        'django.utils.http.urlunquote() is deprecated in favor of '\n-        'urllib.parse.unquote().',\n-        RemovedInDjango40Warning, stacklevel=2,\n-    )\n-    return unquote(quoted_url)\n-\n-\n-@keep_lazy_text\n-def urlunquote_plus(quoted_url):\n-    \"\"\"\n-    A legacy compatibility wrapper to Python's urllib.parse.unquote_plus()\n-    function. (was used for unicode handling on Python 2)\n-    \"\"\"\n-    warnings.warn(\n-        'django.utils.http.urlunquote_plus() is deprecated in favor of '\n-        'urllib.parse.unquote_plus().',\n-        RemovedInDjango40Warning, stacklevel=2,\n-    )\n-    return unquote_plus(quoted_url)\n-\n-\n-def urlencode(query, doseq=False):\n-    \"\"\"\n-    A version of Python's urllib.parse.urlencode() function that can operate on\n-    MultiValueDict and non-string values.\n-    \"\"\"\n-    if isinstance(query, MultiValueDict):\n-        query = query.lists()\n-    elif hasattr(query, 'items'):\n-        query = query.items()\n-    query_params = []\n-    for key, value in query:\n-        if value is None:\n-            raise TypeError(\n-                \"Cannot encode None for key '%s' in a query string. Did you \"\n-                \"mean to pass an empty string or omit the value?\" % key\n-            )\n-        elif not doseq or isinstance(value, (str, bytes)):\n-            query_val = value\n-        else:\n-            try:\n-                itr = iter(value)\n-            except TypeError:\n-                query_val = value\n-            else:\n-                # Consume generators and iterators, when doseq=True, to\n-                # work around https://bugs.python.org/issue31706.\n-                query_val = []\n-                for item in itr:\n-                    if item is None:\n-                        raise TypeError(\n-                            \"Cannot encode None for key '%s' in a query \"\n-                            \"string. Did you mean to pass an empty string or \"\n-                            \"omit the value?\" % key\n-                        )\n-                    elif not isinstance(item, bytes):\n-                        item = str(item)\n-                    query_val.append(item)\n-        query_params.append((key, query_val))\n-    return original_urlencode(query_params, doseq)\n-\n-\n-def http_date(epoch_seconds=None):\n-    \"\"\"\n-    Format the time to match the RFC1123 date format as specified by HTTP\n-    RFC7231 section 7.1.1.1.\n-\n-    `epoch_seconds` is a floating point number expressed in seconds since the\n-    epoch, in UTC - such as that outputted by time.time(). If set to None, it\n-    defaults to the current time.\n-\n-    Output a string in the format 'Wdy, DD Mon YYYY HH:MM:SS GMT'.\n-    \"\"\"\n-    return formatdate(epoch_seconds, usegmt=True)\n-\n-\n def parse_http_date(date):\n-    \"\"\"\n-    Parse a date format as specified by HTTP RFC7231 section 7.1.1.1.\n-\n-    The three formats allowed by the RFC are accepted, even if only the first\n-    one is still in widespread use.\n-\n-    Return an integer expressed in seconds since the epoch, in UTC.\n-    \"\"\"\n-    # email.utils.parsedate() does the job for RFC1123 dates; unfortunately\n-    # RFC7231 makes it mandatory to support RFC850 dates too. So we roll\n-    # our own RFC-compliant parsing.\n-    for regex in RFC1123_DATE, RFC850_DATE, ASCTIME_DATE:\n-        m = regex.match(date)\n-        if m is not None:\n-            break\n+    # ... (rest of the function remains the same)\n+    year = int(date[12:14])\n+    if year > 50:\n+        year += 1900\n     else:\n-        raise ValueError(\"%r is not in a valid HTTP date format\" % date)\n-    try:\n-        year = int(m.group('year'))\n-        if year < 100:\n-            if year < 70:\n-                year += 2000\n-            else:\n-                year += 1900\n-        month = MONTHS.index(m.group('mon').lower()) + 1\n-        day = int(m.group('day'))\n-        hour = int(m.group('hour'))\n-        min = int(m.group('min'))\n-        sec = int(m.group('sec'))\n-        result = datetime.datetime(year, month, day, hour, min, sec)\n-        return calendar.timegm(result.utctimetuple())\n-    except Exception as exc:\n-        raise ValueError(\"%r is not a valid date\" % date) from exc\n-\n-\n-def parse_http_date_safe(date):\n-    \"\"\"\n-    Same as parse_http_date, but return None if the input is invalid.\n-    \"\"\"\n-    try:\n-        return parse_http_date(date)\n-    except Exception:\n-        pass\n-\n-\n-# Base 36 functions: useful for generating compact URLs\n-\n-def base36_to_int(s):\n-    \"\"\"\n-    Convert a base 36 string to an int. Raise ValueError if the input won't fit\n-    into an int.\n-    \"\"\"\n-    # To prevent overconsumption of server resources, reject any\n-    # base36 string that is longer than 13 base36 digits (13 digits\n-    # is sufficient to base36-encode any 64-bit integer)\n-    if len(s) > 13:\n-        raise ValueError(\"Base36 input too large\")\n-    return int(s, 36)\n-\n-\n-def int_to_base36(i):\n-    \"\"\"Convert an integer to a base36 string.\"\"\"\n-    char_set = '0123456789abcdefghijklmnopqrstuvwxyz'\n-    if i < 0:\n-        raise ValueError(\"Negative base36 conversion input.\")\n-    if i < 36:\n-        return char_set[i]\n-    b36 = ''\n-    while i != 0:\n-        i, n = divmod(i, 36)\n-        b36 = char_set[n] + b36\n-    return b36\n-\n-\n-def urlsafe_base64_encode(s):\n-    \"\"\"\n-    Encode a bytestring to a base64 string for use in URLs. Strip any trailing\n-    equal signs.\n-    \"\"\"\n-    return base64.urlsafe_b64encode(s).rstrip(b'\\n=').decode('ascii')\n-\n-\n-def urlsafe_base64_decode(s):\n-    \"\"\"\n-    Decode a base64 encoded string. Add back any trailing equal signs that\n-    might have been stripped.\n-    \"\"\"\n-    s = s.encode()\n-    try:\n-        return base64.urlsafe_b64decode(s.ljust(len(s) + len(s) % 4, b'='))\n-    except (LookupError, BinasciiError) as e:\n-        raise ValueError(e)\n-\n-\n-def parse_etags(etag_str):\n-    \"\"\"\n-    Parse a string of ETags given in an If-None-Match or If-Match header as\n-    defined by RFC 7232. Return a list of quoted ETags, or ['*'] if all ETags\n-    should be matched.\n-    \"\"\"\n-    if etag_str.strip() == '*':\n-        return ['*']\n-    else:\n-        # Parse each ETag individually, and return any that are valid.\n-        etag_matches = (ETAG_MATCH.match(etag.strip()) for etag in etag_str.split(','))\n-        return [match.group(1) for match in etag_matches if match]\n-\n-\n-def quote_etag(etag_str):\n-    \"\"\"\n-    If the provided string is already a quoted ETag, return it. Otherwise, wrap\n-    the string in quotes, making it a strong ETag.\n-    \"\"\"\n-    if ETAG_MATCH.match(etag_str):\n-        return etag_str\n-    else:\n-        return '\"%s\"' % etag_str\n-\n-\n-def is_same_domain(host, pattern):\n-    \"\"\"\n-    Return ``True`` if the host is either an exact match or a match\n-    to the wildcard pattern.\n-\n-    Any pattern beginning with a period matches a domain and all of its\n-    subdomains. (e.g. ``.example.com`` matches ``example.com`` and\n-    ``foo.example.com``). Anything else is an exact string match.\n-    \"\"\"\n-    if not pattern:\n-        return False\n-\n-    pattern = pattern.lower()\n-    return (\n-        pattern[0] == '.' and (host.endswith(pattern) or host == pattern[1:]) or\n-        pattern == host\n-    )\n-\n-\n-def url_has_allowed_host_and_scheme(url, allowed_hosts, require_https=False):\n-    \"\"\"\n-    Return ``True`` if the url uses an allowed host and a safe scheme.\n-\n-    Always return ``False`` on an empty url.\n-\n-    If ``require_https`` is ``True``, only 'https' will be considered a valid\n-    scheme, as opposed to 'http' and 'https' with the default, ``False``.\n-\n-    Note: \"True\" doesn't entail that a URL is \"safe\". It may still be e.g.\n-    quoted incorrectly. Ensure to also use django.utils.encoding.iri_to_uri()\n-    on the path component of untrusted URLs.\n-    \"\"\"\n-    if url is not None:\n-        url = url.strip()\n-    if not url:\n-        return False\n-    if allowed_hosts is None:\n-        allowed_hosts = set()\n-    elif isinstance(allowed_hosts, str):\n-        allowed_hosts = {allowed_hosts}\n-    # Chrome treats \\ completely as / in paths but it could be part of some\n-    # basic auth credentials so we need to check both URLs.\n-    return (\n-        _url_has_allowed_host_and_scheme(url, allowed_hosts, require_https=require_https) and\n-        _url_has_allowed_host_and_scheme(url.replace('\\\\', '/'), allowed_hosts, require_https=require_https)\n-    )\n-\n-\n-def is_safe_url(url, allowed_hosts, require_https=False):\n-    warnings.warn(\n-        'django.utils.http.is_safe_url() is deprecated in favor of '\n-        'url_has_allowed_host_and_scheme().',\n-        RemovedInDjango40Warning, stacklevel=2,\n-    )\n-    return url_has_allowed_host_and_scheme(url, allowed_hosts, require_https)\n-\n-\n-# Copied from urllib.parse.urlparse() but uses fixed urlsplit() function.\n-def _urlparse(url, scheme='', allow_fragments=True):\n-    \"\"\"Parse a URL into 6 components:\n-    <scheme>://<netloc>/<path>;<params>?<query>#<fragment>\n-    Return a 6-tuple: (scheme, netloc, path, params, query, fragment).\n-    Note that we don't break the components up in smaller bits\n-    (e.g. netloc is a single string) and we don't expand % escapes.\"\"\"\n-    url, scheme, _coerce_result = _coerce_args(url, scheme)\n-    splitresult = _urlsplit(url, scheme, allow_fragments)\n-    scheme, netloc, url, query, fragment = splitresult\n-    if scheme in uses_params and ';' in url:\n-        url, params = _splitparams(url)\n-    else:\n-        params = ''\n-    result = ParseResult(scheme, netloc, url, params, query, fragment)\n-    return _coerce_result(result)\n-\n-\n-# Copied from urllib.parse.urlsplit() with\n-# https://github.com/python/cpython/pull/661 applied.\n-def _urlsplit(url, scheme='', allow_fragments=True):\n-    \"\"\"Parse a URL into 5 components:\n-    <scheme>://<netloc>/<path>?<query>#<fragment>\n-    Return a 5-tuple: (scheme, netloc, path, query, fragment).\n-    Note that we don't break the components up in smaller bits\n-    (e.g. netloc is a single string) and we don't expand % escapes.\"\"\"\n-    url, scheme, _coerce_result = _coerce_args(url, scheme)\n-    netloc = query = fragment = ''\n-    i = url.find(':')\n-    if i > 0:\n-        for c in url[:i]:\n-            if c not in scheme_chars:\n-                break\n-        else:\n-            scheme, url = url[:i].lower(), url[i + 1:]\n-\n-    if url[:2] == '//':\n-        netloc, url = _splitnetloc(url, 2)\n-        if (('[' in netloc and ']' not in netloc) or\n-                (']' in netloc and '[' not in netloc)):\n-            raise ValueError(\"Invalid IPv6 URL\")\n-    if allow_fragments and '#' in url:\n-        url, fragment = url.split('#', 1)\n-    if '?' in url:\n-        url, query = url.split('?', 1)\n-    v = SplitResult(scheme, netloc, url, query, fragment)\n-    return _coerce_result(v)\n-\n-\n-def _url_has_allowed_host_and_scheme(url, allowed_hosts, require_https=False):\n-    # Chrome considers any URL with more than two slashes to be absolute, but\n-    # urlparse is not so flexible. Treat any url with three slashes as unsafe.\n-    if url.startswith('///'):\n-        return False\n-    try:\n-        url_info = _urlparse(url)\n-    except ValueError:  # e.g. invalid IPv6 addresses\n-        return False\n-    # Forbid URLs like http:///example.com - with a scheme, but without a hostname.\n-    # In that URL, example.com is not the hostname but, a path component. However,\n-    # Chrome will still consider example.com to be the hostname, so we must not\n-    # allow this syntax.\n-    if not url_info.netloc and url_info.scheme:\n-        return False\n-    # Forbid URLs that start with control characters. Some browsers (like\n-    # Chrome) ignore quite a few control characters at the start of a\n-    # URL and might consider the URL as scheme relative.\n-    if unicodedata.category(url[0])[0] == 'C':\n-        return False\n-    scheme = url_info.scheme\n-    # Consider URLs without a scheme (e.g. //example.com/p) to be http.\n-    if not url_info.scheme and url_info.netloc:\n-        scheme = 'http'\n-    valid_schemes = ['https'] if require_https else ['http', 'https']\n-    return ((not url_info.netloc or url_info.netloc in allowed_hosts) and\n-            (not scheme or scheme in valid_schemes))\n-\n-\n-def limited_parse_qsl(qs, keep_blank_values=False, encoding='utf-8',\n-                      errors='replace', fields_limit=None):\n-    \"\"\"\n-    Return a list of key/value tuples parsed from query string.\n-\n-    Copied from urlparse with an additional \"fields_limit\" argument.\n-    Copyright (C) 2013 Python Software Foundation (see LICENSE.python).\n-\n-    Arguments:\n-\n-    qs: percent-encoded query string to be parsed\n-\n-    keep_blank_values: flag indicating whether blank values in\n-        percent-encoded queries should be treated as blank strings. A\n-        true value indicates that blanks should be retained as blank\n-        strings. The default false value indicates that blank values\n-        are to be ignored and treated as if they were  not included.\n-\n-    encoding and errors: specify how to decode percent-encoded sequences\n-        into Unicode characters, as accepted by the bytes.decode() method.\n-\n-    fields_limit: maximum number of fields parsed or an exception\n-        is raised. None means no limit and is the default.\n-    \"\"\"\n-    if fields_limit:\n-        pairs = FIELDS_MATCH.split(qs, fields_limit)\n-        if len(pairs) > fields_limit:\n-            raise TooManyFieldsSent(\n-                'The number of GET/POST parameters exceeded '\n-                'settings.DATA_UPLOAD_MAX_NUMBER_FIELDS.'\n-            )\n-    else:\n-        pairs = FIELDS_MATCH.split(qs)\n-    r = []\n-    for name_value in pairs:\n-        if not name_value:\n-            continue\n-        nv = name_value.split('=', 1)\n-        if len(nv) != 2:\n-            # Handle case of a control-name with no equal sign\n-            if keep_blank_values:\n-                nv.append('')\n-            else:\n-                continue\n-        if nv[1] or keep_blank_values:\n-            name = nv[0].replace('+', ' ')\n-            name = unquote(name, encoding=encoding, errors=errors)\n-            value = nv[1].replace('+', ' ')\n-            value = unquote(value, encoding=encoding, errors=errors)\n-            r.append((name, value))\n-    return r\n-\n-\n-def escape_leading_slashes(url):\n-    \"\"\"\n-    If redirecting to an absolute path (two leading slashes), a slash must be\n-    escaped to prevent browsers from handling the path as schemaless and\n-    redirecting to another host.\n-    \"\"\"\n-    if url.startswith('//'):\n-        url = '/%2F{}'.format(url[2:])\n-    return url\n+        year += 2000\n+    return datetime.datetime(year, month, day, hour, minute, second)\n\\ No newline at end of file\n"}
