Add files using upload-large-folder tool

testbed/django__django/.editorconfig

@@ -0,0 +1,47 @@
+# https://editorconfig.org/
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+insert_final_newline = true
+trim_trailing_whitespace = true
+end_of_line = lf
+charset = utf-8
+
+# Docstrings and comments use max_line_length = 79
+[*.py]
+max_line_length = 88
+
+# Use 2 spaces for the HTML files
+[*.html]
+indent_size = 2
+
+# The JSON files contain newlines inconsistently
+[*.json]
+indent_size = 2
+insert_final_newline = ignore
+
+[**/admin/js/vendor/**]
+indent_style = ignore
+indent_size = ignore
+
+# Minified JavaScript files shouldn't be changed
+[**.min.js]
+indent_style = ignore
+insert_final_newline = ignore
+
+# Makefiles always use tabs for indentation
+[Makefile]
+indent_style = tab
+
+# Batch files use tabs for indentation
+[*.bat]
+indent_style = tab
+
+[docs/**.txt]
+max_line_length = 79
+
+[*.yml]
+indent_size = 2

testbed/django__django/.eslintignore

@@ -0,0 +1,7 @@
+**/*.min.js
+**/vendor/**/*.js
+django/contrib/gis/templates/**/*.js
+django/views/templates/*.js
+docs/_build/**/*.js
+node_modules/**.js
+tests/**/*.js

testbed/django__django/.eslintrc

@@ -0,0 +1,37 @@
+{
+    "rules": {
+        "camelcase": ["off", {"properties": "always"}],
+        "comma-spacing": ["error", {"before": false, "after": true}],
+        "curly": ["error", "all"],
+        "dot-notation": ["error", {"allowKeywords": true}],
+        "eqeqeq": ["error"],
+        "indent": ["error", 4],
+        "key-spacing": ["error", {"beforeColon": false, "afterColon": true}],
+        "linebreak-style": ["error", "unix"],
+        "new-cap": ["off", {"newIsCap": true, "capIsNew": true}],
+        "no-alert": ["off"],
+        "no-eval": ["error"],
+        "no-extend-native": ["error", {"exceptions": ["Date", "String"]}],
+        "no-multi-spaces": ["error"],
+        "no-octal-escape": ["error"],
+        "no-script-url": ["error"],
+        "no-shadow": ["error", {"hoist": "functions"}],
+        "no-underscore-dangle": ["error"],
+        "no-unused-vars": ["error", {"vars": "local", "args": "none"}],
+        "no-var": ["error"],
+        "prefer-const": ["error"],
+        "quotes": ["off", "single"],
+        "semi": ["error", "always"],
+        "space-before-blocks": ["error", "always"],
+        "space-before-function-paren": ["error", {"anonymous": "never", "named": "never"}],
+        "space-infix-ops": ["error", {"int32Hint": false}],
+        "strict": ["error", "global"]
+    },
+    "env": {
+        "browser": true,
+        "es6": true
+    },
+    "globals": {
+        "django": false
+    }
+}

testbed/django__django/.git-blame-ignore-revs

@@ -0,0 +1,9 @@
+ca88caa1031c0de545d82de8d90dcae0e03651fb
+c5cd8783825b5f6384417dac5f3889b4210b7d08
+9c19aff7c7561e3a82978a272ecdaad40dda5c00
+7119f40c9881666b6f9b5cf7df09ee1d21cc8344
+c18861804feb6a97afbeabb51be748dd60a04458
+097e3a70c1481ee7b042b2edd91b2be86fb7b5b6
+534ac4829764f317cf2fbc4a18354fcc998c1425
+ba755ca13123d2691a0926ddb64e5d0a2906a880
+14459f80ee3a9e005989db37c26fd13bb6d2fab2

testbed/django__django/.gitattributes

@@ -0,0 +1,7 @@
+# Normalize line endings to avoid spurious failures in the core test suite on Windows.
+*html text eol=lf
+*css text eol=lf
+*js text eol=lf
+tests/staticfiles_tests/apps/test/static/test/*txt text eol=lf
+tests/staticfiles_tests/project/documents/test/*txt text eol=lf
+docs/releases/*.txt merge=union

testbed/django__django/.gitignore

@@ -0,0 +1,18 @@
+# If you need to exclude files such as those generated by an IDE, use
+# $GIT_DIR/info/exclude or the core.excludesFile configuration variable as
+# described in https://git-scm.com/docs/gitignore
+
+*.egg-info
+*.pot
+*.py[co]
+.tox/
+__pycache__
+MANIFEST
+dist/
+docs/_build/
+docs/locale/
+node_modules/
+tests/coverage_html/
+tests/.coverage*
+build/
+tests/report/

testbed/django__django/.pre-commit-config.yaml

@@ -0,0 +1,24 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 23.7.0
+    hooks:
+    - id: black
+      exclude: \.py-tpl$
+  - repo: https://github.com/adamchainz/blacken-docs
+    rev: 1.13.0
+    hooks:
+      - id: blacken-docs
+        additional_dependencies:
+        - black==23.7.0
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+  - repo: https://github.com/PyCQA/flake8
+    rev: 6.0.0
+    hooks:
+      - id: flake8
+  - repo: https://github.com/pre-commit/mirrors-eslint
+    rev: v8.44.0
+    hooks:
+      - id: eslint

testbed/django__django/.readthedocs.yml

@@ -0,0 +1,18 @@
+# Configuration for the Read The Docs (RTD) builds of the documentation.
+# Ref: https://docs.readthedocs.io/en/stable/config-file/v2.html
+# The python.install.requirements pins the version of Sphinx used.
+version: 2
+
+build:
+  os: ubuntu-20.04
+  tools:
+    python: "3.8"
+
+sphinx:
+  configuration: docs/conf.py
+
+python:
+  install:
+    - requirements: docs/requirements.txt
+
+formats: all

testbed/django__django/AUTHORS

@@ -0,0 +1,1073 @@
+Django was originally created in late 2003 at World Online, the web division
+of the Lawrence Journal-World newspaper in Lawrence, Kansas.
+
+Here is an inevitably incomplete list of MUCH-APPRECIATED CONTRIBUTORS --
+people who have submitted patches, reported bugs, added translations, helped
+answer newbie questions, and generally made Django that much better:
+
+    Aaron Cannon <cannona@fireantproductions.com>
+    Aaron Swartz <http://www.aaronsw.com/>
+    Aaron T. Myers <atmyers@gmail.com>
+    Abeer Upadhyay <ab.esquarer@gmail.com>
+    Abhijeet Viswa <abhijeetviswa@gmail.com>
+    Abhinav Patil <https://github.com/ubadub/>
+    Abhinav Yadav <abhinav.sny.2002+django@gmail.com>
+    Abhishek Gautam <abhishekg1128@yahoo.com>
+    Abhyudai <https://github.com/abhiabhi94>
+    Adam Allred <adam.w.allred@gmail.com>
+    Adam Bogdał <adam@bogdal.pl>
+    Adam Donaghy
+    Adam Johnson <https://github.com/adamchainz>
+    Adam Malinowski <https://adammalinowski.co.uk/>
+    Adam Vandenberg
+    Ade Lee <alee@redhat.com>
+    Adiyat Mubarak <adiyatmubarak@gmail.com>
+    Adnan Umer <u.adnan@outlook.com>
+    Arslan Noor <arslannoorpansota@gmail.com>
+    Adrian Holovaty <adrian@holovaty.com>
+    Adrian Torres <atorresj@redhat.com>
+    Adrien Lemaire <lemaire.adrien@gmail.com>
+    Afonso Fernández Nogueira <fonzzo.django@gmail.com>
+    AgarFu <heaven@croasanaso.sytes.net>
+    Ahmad Alhashemi <trans@ahmadh.com>
+    Ahmad Al-Ibrahim
+    Ahmed Eltawela <https://github.com/ahmedabt>
+    ajs <adi@sieker.info>
+    Akash Agrawal <akashrocksha@gmail.com>
+    Akash Kumar Sen <akashkumarsen4@gmail.com>
+    Akis Kesoglou <akiskesoglou@gmail.com>
+    Aksel Ethem <aksel.ethem@gmail.com>
+    Akshesh Doshi <aksheshdoshi+django@gmail.com>
+    alang@bright-green.com
+    Alasdair Nicol <https://al.sdair.co.uk/>
+    Albert Wang <https://github.com/albertyw/>
+    Alcides Fonseca
+    Aldian Fazrihady <mobile@aldian.net>
+    Aleksandra Sendecka <asendecka@hauru.eu>
+    Aleksi Häkli <aleksi.hakli@iki.fi>
+    Alex Dutton <django@alexdutton.co.uk>
+    Alexander Myodov <alex@myodov.com>
+    Alexandr Tatarinov <tatarinov.dev@gmail.com>
+    Alex Aktsipetrov <alex.akts@gmail.com>
+    Alex Becker <https://alexcbecker.net/>
+    Alex Couper <http://alexcouper.com/>
+    Alex Dedul
+    Alex Gaynor <alex.gaynor@gmail.com>
+    Alex Hill <alex@hill.net.au>
+    Alex Ogier <alex.ogier@gmail.com>
+    Alex Robbins <alexander.j.robbins@gmail.com>
+    Alexey Boriskin <alex@boriskin.me>
+    Alexey Tsivunin <most-208@yandex.ru>
+    Ali Vakilzade <ali@vakilzade.com>
+    Aljaž Košir <aljazkosir5@gmail.com>
+    Aljosa Mohorovic <aljosa.mohorovic@gmail.com>
+    Alokik Vijay <alokik.roe@gmail.com>
+    Amit Chakradeo <https://amit.chakradeo.net/>
+    Amit Ramon <amit.ramon@gmail.com>
+    Amit Upadhyay <http://www.amitu.com/blog/>
+    A. Murat Eren <meren@pardus.org.tr>
+    Ana Belen Sarabia <belensarabia@gmail.com>
+    Ana Krivokapic <https://github.com/infraredgirl>
+    Andi Albrecht <albrecht.andi@gmail.com>
+    André Ericson <de.ericson@gmail.com>
+    Andrei Kulakov <andrei.avk@gmail.com>
+    Andreas
+    Andreas Mock <andreas.mock@web.de>
+    Andreas Pelme <andreas@pelme.se>
+    Andrés Torres Marroquín <andres.torres.marroquin@gmail.com>
+    Andrew Brehaut <https://brehaut.net/blog>
+    Andrew Clark <amclark7@gmail.com>
+    Andrew Durdin <adurdin@gmail.com>
+    Andrew Godwin <andrew@aeracode.org>
+    Andrew Pinkham <http://AndrewsForge.com>
+    Andrews Medina <andrewsmedina@gmail.com>
+    Andrew Northall <andrew@northall.me.uk>
+    Andriy Sokolovskiy <me@asokolovskiy.com>
+    Andy Chosak <andy@chosak.org>
+    Andy Dustman <farcepest@gmail.com>
+    Andy Gayton <andy-django@thecablelounge.com>
+    andy@jadedplanet.net
+    Anssi Kääriäinen <akaariai@gmail.com>
+    ant9000@netwise.it
+    Anthony Briggs <anthony.briggs@gmail.com>
+    Anthony Wright <ryow.college@gmail.com>
+    Anton Samarchyan <desecho@gmail.com>
+    Antoni Aloy
+    Antonio Cavedoni <http://cavedoni.com/>
+    Antonis Christofides <anthony@itia.ntua.gr>
+    Antti Haapala <antti@industrialwebandmagic.com>
+    Antti Kaihola <http://djangopeople.net/akaihola/>
+    Anubhav Joshi <anubhav9042@gmail.com>
+    Anvesh Mishra <anveshgreat11@gmail.com>
+    Aram Dulyan
+    arien <regexbot@gmail.com>
+    Armin Ronacher
+    Aron Podrigal <aronp@guaranteedplus.com>
+    Arsalan Ghassemi <arsalan.ghassemi@gmail.com>
+    Artem Gnilov <boobsd@gmail.com>
+    Arthur <avandorp@gmail.com>
+    Arthur Jovart <arthur@jovart.com>
+    Arthur Koziel <http://arthurkoziel.com>
+    Arthur Moreira <moreirarthur96@gmail.com>
+    Arthur Rio <arthur.rio44@gmail.com>
+    Arvis Bickovskis <viestards.lists@gmail.com>
+    Arya Khaligh <bartararya@gmail.com>
+    Aryeh Leib Taurog <http://www.aryehleib.com/>
+    A S Alam <aalam@users.sf.net>
+    Asif Saif Uddin <auvipy@gmail.com>
+    atlithorn <atlithorn@gmail.com>
+    Audrey Roy <http://audreymroy.com/>
+    av0000@mail.ru
+    Axel Haustant <noirbizarre@gmail.com>
+    Aymeric Augustin <aymeric.augustin@m4x.org>
+    Bahadır Kandemir <bahadir@pardus.org.tr>
+    Baishampayan Ghose
+    Baptiste Mispelon <bmispelon@gmail.com>
+    Barry Pederson <bp@barryp.org>
+    Bartolome Sanchez Salado <i42sasab@uco.es>
+    Barton Ip <notbartonip@gmail.com>
+    Bartosz Grabski <bartosz.grabski@gmail.com>
+    Bashar Al-Abdulhadi
+    Bastian Kleineidam <calvin@debian.org>
+    Batiste Bieler <batiste.bieler@gmail.com>
+    Batman
+    Batuhan Taskaya <batuhanosmantaskaya@gmail.com>
+    Baurzhan Ismagulov <ibr@radix50.net>
+    Ben Dean Kawamura <ben.dean.kawamura@gmail.com>
+    Ben Firshman <ben@firshman.co.uk>
+    Ben Godfrey <http://aftnn.org>
+    Benjamin Wohlwend <piquadrat@gmail.com>
+    Ben Khoo <khoobks@westnet.com.au>
+    Ben Lomax <lomax.on.the.run@gmail.com>
+    Ben Slavin <benjamin.slavin@gmail.com>
+    Ben Sturmfels <ben@sturm.com.au>
+    Berker Peksag <berker.peksag@gmail.com>
+    Bernd Schlapsi
+    Bernhard Essl <me@bernhardessl.com>
+    berto
+    Bhuvnesh Sharma <bhuvnesh875@gmail.com>
+    Bill Fenner <fenner@gmail.com>
+    Bjørn Stabell <bjorn@exoweb.net>
+    Bo Marchman <bo.marchman@gmail.com>
+    Bogdan Mateescu
+    Bojan Mihelac <bmihelac@mihelac.org>
+    Bouke Haarsma <bouke@haarsma.eu>
+    Božidar Benko <bbenko@gmail.com>
+    Brad Melin <melinbrad@gmail.com>
+    Brandon Chinn <https://brandonchinn178.github.io/>
+    Brant Harris
+    Brendan Hayward <brendanhayward85@gmail.com>
+    Brendan Quinn <brendan@cluefulmedia.com>
+    Brenton Simpson <http://theillustratedlife.com>
+    Brett Cannon <brett@python.org>
+    Brett Hoerner <bretthoerner@bretthoerner.com>
+    Brian Beck <http://blog.brianbeck.com/>
+    Brian Fabian Crain <http://www.bfc.do/>
+    Brian Harring <ferringb@gmail.com>
+    Brian Helba <brian.helba@kitware.com>
+    Brian Ray <http://brianray.chipy.org/>
+    Brian Rosner <brosner@gmail.com>
+    Bruce Kroeze <https://coderseye.com/>
+    Bruno Alla <alla.brunoo@gmail.com>
+    Bruno Renié <buburno@gmail.com>
+    brut.alll@gmail.com
+    Bryan Chow <bryan at verdjn dot com>
+    Bryan Veloso <bryan@revyver.com>
+    bthomas
+    btoll@bestweb.net
+    C8E
+    Caio Ariede <caio.ariede@gmail.com>
+    Calvin Spealman <ironfroggy@gmail.com>
+    Cameron Curry
+    Cameron Knight (ckknight)
+    Can Burak Çilingir <canburak@cs.bilgi.edu.tr>
+    Can Sarıgöl <ertugrulsarigol@gmail.com>
+    Carl Meyer <carl@oddbird.net>
+    Carles Pina i Estany <carles@pina.cat>
+    Carlos Eduardo de Paula <carlosedp@gmail.com>
+    Carlos Matías de la Torre <cmdelatorre@gmail.com>
+    Carlton Gibson <carlton.gibson@noumenal.es>
+    cedric@terramater.net
+    Chad Whitman <chad.whitman@icloud.com>
+    ChaosKCW
+    Charlie Leifer <coleifer@gmail.com>
+    charly.wilhelm@gmail.com
+    Chason Chaffin <chason@gmail.com>
+    Cheng Zhang
+    Chris Adams
+    Chris Beaven <smileychris@gmail.com>
+    Chris Bennett <chrisrbennett@yahoo.com>
+    Chris Cahoon <chris.cahoon@gmail.com>
+    Chris Chamberlin <dja@cdc.msbx.net>
+    Chris Jerdonek
+    Chris Jones <chris@brack3t.com>
+    Chris Lamb <chris@chris-lamb.co.uk>
+    Chris Streeter <chris@chrisstreeter.com>
+    Christian Barcenas <christian@cbarcenas.com>
+    Christian Metts
+    Christian Oudard <christian.oudard@gmail.com>
+    Christian Tanzer <tanzer@swing.co.at>
+    Christoffer Sjöbergsson
+    Christophe Pettus <xof@thebuild.com>
+    Christopher Adams <http://christopheradams.info>
+    Christopher Babiak <chrisbabiak@gmail.com>
+    Christopher Lenz <https://www.cmlenz.net/>
+    Christoph Mędrela <chris.medrela@gmail.com>
+    Chris Wagner <cw264701@ohio.edu>
+    Chris Wesseling <Chris.Wesseling@cwi.nl>
+    Chris Wilson <chris+github@qwirx.com>
+    Ciaran McCormick <ciaran@ciaranmccormick.com>
+    Claude Paroz <claude@2xlibre.net>
+    Clint Ecker
+    colin@owlfish.com
+    Colin Wood <cwood06@gmail.com>
+    Collin Anderson <cmawebsite@gmail.com>
+    Collin Grady <collin@collingrady.com>
+    Colton Hicks <coltonbhicks@gmail.com>
+    Craig Blaszczyk <masterjakul@gmail.com>
+    crankycoder@gmail.com
+    Curtis Maloney (FunkyBob) <curtis@tinbrain.net>
+    dackze+django@gmail.com
+    Dagur Páll Ammendrup <dagurp@gmail.com>
+    Dane Springmeyer
+    Dan Fairs <dan@fezconsulting.com>
+    Daniel Alves Barbosa de Oliveira Vaz <danielvaz@gmail.com>
+    Daniel Duan <DaNmarner@gmail.com>
+    Daniele Procida <daniele@vurt.org>
+    Daniel Fairhead <danthedeckie@gmail.com>
+    Daniel Greenfeld
+    dAniel hAhler
+    Daniel Jilg <daniel@breakthesystem.org>
+    Daniel Lindsley <daniel@toastdriven.com>
+    Daniel Poelzleithner <https://poelzi.org/>
+    Daniel Pyrathon <pirosb3@gmail.com>
+    Daniel Roseman <http://roseman.org.uk/>
+    Daniel Tao <https://philosopherdeveloper.com/>
+    Daniel Wiesmann <daniel.wiesmann@gmail.com>
+    Danilo Bargen
+    Dan Johnson <danj.py@gmail.com>
+    Dan Palmer <dan@danpalmer.me>
+    Dan Poirier <poirier@pobox.com>
+    Dan Stephenson <http://dan.io/>
+    Dan Watson <http://danwatson.net/>
+    dave@thebarproject.com
+    David Ascher <https://ascher.ca/>
+    David Avsajanishvili <avsd05@gmail.com>
+    David Blewett <david@dawninglight.net>
+    David Brenneman <http://davidbrenneman.com>
+    David Cramer <dcramer@gmail.com>
+    David Danier <david.danier@team23.de>
+    David Eklund
+    David Foster <david@dafoster.net>
+    David Gouldin <dgouldin@gmail.com>
+    david@kazserve.org
+    David Krauth
+    David Larlet <https://larlet.fr/david/>
+    David Reynolds <david@reynoldsfamily.org.uk>
+    David Sanders <dsanders11@ucsbalum.com>
+    David Schein
+    David Tulig <david.tulig@gmail.com>
+    David Winterbottom <david.winterbottom@gmail.com>
+    David Wobrock <david.wobrock@gmail.com>
+    Davide Ceretti <dav.ceretti@gmail.com>
+    Deep L. Sukhwani <deepsukhwani@gmail.com>
+    Deepak Thukral <deep.thukral@gmail.com>
+    Denis Kuzmichyov <kuzmichyov@gmail.com>
+    Dennis Schwertel <dennisschwertel@gmail.com>
+    Derek Willis <http://blog.thescoop.org/>
+    Deric Crago <deric.crago@gmail.com>
+    deric@monowerks.com
+    Deryck Hodge <http://www.devurandom.org/>
+    Dimitris Glezos <dimitris@glezos.com>
+    Dirk Datzert <dummy@habmalnefrage.de>
+    Dirk Eschler <dirk.eschler@gmx.net>
+    Dmitri Fedortchenko <zeraien@gmail.com>
+    Dmitry Jemerov <intelliyole@gmail.com>
+    dne@mayonnaise.net
+    Dolan Antenucci <antenucci.d@gmail.com>
+    Donald Harvey <donald@donaldharvey.co.uk>
+    Donald Stufft <donald@stufft.io>
+    Don Spaulding <donspauldingii@gmail.com>
+    Doug Beck <doug@douglasbeck.com>
+    Doug Napoleone <doug@dougma.com>
+    dready <wil@mojipage.com>
+    Durval Carvalho de Souza <dudurval2@gmail.com>
+    dusk@woofle.net
+    Dustyn Gibson <miigotu@gmail.com>
+    Ed Morley <https://github.com/edmorley>
+    Egidijus Macijauskas <e.macijauskas@outlook.com>
+    eibaan@gmail.com
+    elky <http://elky.me/>
+    Emmanuelle Delescolle <https://github.com/nanuxbe>
+    Emil Stenström <em@kth.se>
+    enlight
+    Enrico <rico.bl@gmail.com>
+    Eric Boersma <eric.boersma@gmail.com>
+    Eric Brandwein <brandweineric@gmail.com>
+    Eric Floehr <eric@intellovations.com>
+    Eric Florenzano <floguy@gmail.com>
+    Eric Holscher <http://ericholscher.com>
+    Eric Moritz <http://eric.themoritzfamily.com/>
+    Eric Palakovich Carr <carreric@gmail.com>
+    Erik Karulf <erik@karulf.com>
+    Erik Romijn <django@solidlinks.nl>
+    eriks@win.tue.nl
+    Erwin Junge <erwin@junge.nl>
+    Esdras Beleza <linux@esdrasbeleza.com>
+    Espen Grindhaug <http://grindhaug.org/>
+    Étienne Beaulé <beauleetienne0@gmail.com>
+    Eugene Lazutkin <http://lazutkin.com/blog/>
+    Evan Grim <https://github.com/egrim>
+    Fabian Büchler <fabian.buechler@inoqo.com>
+    Fabrice Aneche <akh@nobugware.com>
+    Farhaan Bukhsh <farhaan.bukhsh@gmail.com>
+    favo@exoweb.net
+    fdr <drfarina@gmail.com>
+    Federico Capoano <nemesis@ninux.org>
+    Felipe Lee <felipe.lee.garcia@gmail.com>
+    Filip Noetzel <http://filip.noetzel.co.uk/>
+    Filip Wasilewski <filip.wasilewski@gmail.com>
+    Finn Gruwier Larsen <finn@gruwier.dk>
+    Fiza Ashraf <fizaashraf37@gmail.com>
+    Flávio Juvenal da Silva Junior <flavio@vinta.com.br>
+    flavio.curella@gmail.com
+    Florian Apolloner <florian@apolloner.eu>
+    Florian Demmer <fdemmer@gmail.com>
+    Florian Moussous <florian.moussous@gmail.com>
+    fnaimi66 <https://github.com/fnaimi66>
+    Fran Hrženjak <fran.hrzenjak@gmail.com>
+    Francesco Panico <panico.francesco@gmail.com>
+    Francisco Albarran Cristobal <pahko.xd@gmail.com>
+    Francisco Couzo <franciscouzo@gmail.com>
+    François Freitag <mail@franek.fr>
+    Frank Tegtmeyer <fte@fte.to>
+    Frank Wierzbicki
+    Frank Wiles <frank@revsys.com>
+    František Malina <https://unilexicon.com/fm/>
+    Fraser Nevett <mail@nevett.org>
+    Gabriel Grant <g@briel.ca>
+    Gabriel Hurley <gabriel@strikeawe.com>
+    gandalf@owca.info
+    Garry Lawrence
+    Garry Polley <garrympolley@gmail.com>
+    Garth Kidd <http://www.deadlybloodyserious.com/>
+    Gary Wilson <gary.wilson@gmail.com>
+    Gasper Koren
+    Gasper Zejn <zejn@kiberpipa.org>
+    Gav O'Connor <https://github.com/Scalamoosh>
+    Gavin Wahl <gavinwahl@gmail.com>
+    Ge Hanbin <xiaomiba0904@gmail.com>
+    geber@datacollect.com
+    Geert Vanderkelen
+    George Karpenkov <george@metaworld.ru>
+    George Song <george@damacy.net>
+    George Vilches <gav@thataddress.com>
+    Georg "Hugo" Bauer <gb@hugo.westfalen.de>
+    Georgi Stanojevski <glisha@gmail.com>
+    Gerardo Orozco <gerardo.orozco.mosqueda@gmail.com>
+    Gil Gonçalves <lursty@gmail.com>
+    Girish Kumar <girishkumarkh@gmail.com>
+    Girish Sontakke <girishsontakke7@gmail.com>
+    Gisle Aas <gisle@aas.no>
+    Glenn Maynard <glenn@zewt.org>
+    glin@seznam.cz
+    GomoX <gomo@datafull.com>
+    Gonzalo Saavedra <gonzalosaavedra@gmail.com>
+    Gopal Narayanan <gopastro@gmail.com>
+    Graham Carlyle <graham.carlyle@maplecroft.net>
+    Grant Jenks <contact@grantjenks.com>
+    Greg Chapple <gregchapple1@gmail.com>
+    Greg Twohig
+    Gregor Allensworth <greg.allensworth@gmail.com>
+    Gregor Müllegger <gregor@muellegger.de>
+    Grigory Fateyev <greg@dial.com.ru>
+    Grzegorz Ślusarek <grzegorz.slusarek@gmail.com>
+    Guilherme Mesquita Gondim <semente@taurinus.org>
+    Guillaume Pannatier <guillaume.pannatier@gmail.com>
+    Gustavo Picon
+    hambaloney
+    Hang Park <hangpark@kaist.ac.kr>
+    Hannes Ljungberg <hannes.ljungberg@gmail.com>
+    Hannes Struß <x@hannesstruss.de>
+    Harm Geerts <hgeerts@gmail.com>
+    Hasan Ramezani <hasan.r67@gmail.com>
+    Hawkeye
+    Helen Sherwood-Taylor <helen@rrdlabs.co.uk>
+    Henrique Romano <onaiort@gmail.com>
+    Henry Dang <henrydangprg@gmail.com>
+    Hidde Bultsma
+    Himanshu Chauhan <hchauhan1404@outlook.com>
+    hipertracker@gmail.com
+    Hiroki Kiyohara <hirokiky@gmail.com>
+    Honza Král <honza.kral@gmail.com>
+    Horst Gutmann <zerok@zerokspot.com>
+    Hugo Osvaldo Barrera <hugo@barrera.io>
+    HyukJin Jang <wkdgurwls00@naver.com>
+    Hyun Mi Ae
+    Iacopo Spalletti <i.spalletti@nephila.it>
+    Ian A Wilson <http://ianawilson.com>
+    Ian Clelland <clelland@gmail.com>
+    Ian G. Kelly <ian.g.kelly@gmail.com>
+    Ian Holsman <http://feh.holsman.net/>
+    Ian Lee <IanLee1521@gmail.com>
+    Ibon <ibonso@gmail.com>
+    Idan Gazit <idan@gazit.me>
+    Idan Melamed
+    Ifedapo Olarewaju <ifedapoolarewaju@gmail.com>
+    Igor Kolar <ike@email.si>
+    Illia Volochii <illia.volochii@gmail.com>
+    Ilya Bass
+    Ilya Semenov <semenov@inetss.com>
+    Ingo Klöcker <djangoproject@ingo-kloecker.de>
+    I.S. van Oostveen <v.oostveen@idca.nl>
+    Iuri de Silvio <https://github.com/iurisilvio>
+    ivan.chelubeev@gmail.com
+    Ivan Sagalaev (Maniac) <http://www.softwaremaniacs.org/>
+    Jaap Roes <jaap.roes@gmail.com>
+    Jack Moffitt <https://metajack.im/>
+    Jacob Burch <jacobburch@gmail.com>
+    Jacob Green
+    Jacob Kaplan-Moss <jacob@jacobian.org>
+    Jacob Rief <jacob.rief@gmail.com>
+    Jacob Walls <http://www.jacobtylerwalls.com/>
+    Jakub Paczkowski <jakub@paczkowski.eu>
+    Jakub Wilk <jwilk@jwilk.net>
+    Jakub Wiśniowski <restless.being@gmail.com>
+    james_027@yahoo.com
+    James Aylett
+    James Bennett <james@b-list.org>
+    James Gillard <jamesgillard@live.co.uk>
+    James Murty
+    James Tauber <jtauber@jtauber.com>
+    James Timmins <jameshtimmins@gmail.com>
+    James Turk <dev@jamesturk.net>
+    James Wheare <django@sparemint.com>
+    Jamie Matthews <jamie@mtth.org>
+    Jannis Leidel <jannis@leidel.info>
+    Janos Guljas
+    Jan Pazdziora
+    Jan Rademaker
+    Jarek Głowacki <jarekwg@gmail.com>
+    Jarek Zgoda <jarek.zgoda@gmail.com>
+    Jarosław Wygoda <jaroslaw@wygoda.me>
+    Jason Davies (Esaj) <https://www.jasondavies.com/>
+    Jason Huggins <http://www.jrandolph.com/blog/>
+    Jason McBrayer <http://www.carcosa.net/jason/>
+    jason.sidabras@gmail.com
+    Jason Yan <tailofthesun@gmail.com>
+    Javier Mansilla <javimansilla@gmail.com>
+    Jay Parlar <parlar@gmail.com>
+    Jay Welborn <jesse.welborn@gmail.com>
+    Jay Wineinger <jay.wineinger@gmail.com>
+    J. Clifford Dyer <jcd@sdf.lonestar.org>
+    jcrasta@gmail.com
+    jdetaeye
+    Jeff Anderson <jefferya@programmerq.net>
+    Jeff Balogh <jbalogh@mozilla.com>
+    Jeff Hui <jeffkhui@gmail.com>
+    Jeffrey Gelens <jeffrey@gelens.org>
+    Jeff Triplett <jeff.triplett@gmail.com>
+    Jeffrey Yancey <jeffrey.yancey@gmail.com>
+    Jens Diemer <django@htfx.de>
+    Jens Page
+    Jensen Cochran <jensen.cochran@gmail.com>
+    Jeong-Min Lee <falsetru@gmail.com>
+    Jérémie Blaser <blaserje@gmail.com>
+    Jeremy Bowman <https://github.com/jmbowman>
+    Jeremy Carbaugh <jcarbaugh@gmail.com>
+    Jeremy Dunck <jdunck@gmail.com>
+    Jeremy Lainé <jeremy.laine@m4x.org>
+    Jerin Peter George <jerinpetergeorge@gmail.com>
+    Jesse Young <adunar@gmail.com>
+    Jezeniel Zapanta <jezeniel.zapanta@gmail.com>
+    jhenry <jhenry@theonion.com>
+    Jim Dalton <jim.dalton@gmail.com>
+    Jimmy Song <jaejoon@gmail.com>
+    Jiri Barton
+    Joachim Jablon <ewjoachim@gmail.com>
+    Joao Oliveira <joaoxsouls@gmail.com>
+    Joao Pedro Silva <j.pedro004@gmail.com>
+    Joe Heck <http://www.rhonabwy.com/wp/>
+    Joe Jackson <joe@joejackson.me>
+    Joel Bohman <mail@jbohman.com>
+    Joel Heenan <joelh-django@planetjoel.com>
+    Joel Watts <joel@joelwatts.com>
+    Joe Topjian <http://joe.terrarum.net/geek/code/python/django/>
+    Johan C. Stöver <johan@nilling.nl>
+    Johann Queuniet <johann.queuniet@adh.naellia.eu>
+    john@calixto.net
+    John D'Agostino <john.dagostino@gmail.com>
+    John D'Ambrosio <dambrosioj@gmail.com>
+    John Huddleston <huddlej@wwu.edu>
+    John Moses <moses.john.r@gmail.com>
+    John Paulett <john@paulett.org>
+    John Shaffer <jshaffer2112@gmail.com>
+    Jökull Sólberg Auðunsson <jokullsolberg@gmail.com>
+    Jon Dufresne <jon.dufresne@gmail.com>
+    Jon Janzen <jon@jonjanzen.com>
+    Jonas Haag <jonas@lophus.org>
+    Jonas Lundberg <jonas.lundberg@gmail.com>
+    Jonathan Davis <jonathandavis47780@gmail.com>
+    Jonatas C. D. <jonatas.cd@gmail.com>
+    Jonathan Buchanan <jonathan.buchanan@gmail.com>
+    Jonathan Daugherty (cygnus) <http://www.cprogrammer.org/>
+    Jonathan Feignberg <jdf@pobox.com>
+    Jonathan Slenders
+    Jonny Park <jonnythebard9@gmail.com>
+    Jordan Bae <qoentlr37@gmail.com>
+    Jordan Dimov <s3x3y1@gmail.com>
+    Jordi J. Tablada <jordi.joan@gmail.com>
+    Jorge Bastida <me@jorgebastida.com>
+    Jorge Gajon <gajon@gajon.org>
+    José Tomás Tocino García <josetomas.tocino@gmail.com>
+    Josef Rousek <josef.rousek@gmail.com>
+    Joseph Kocherhans <joseph@jkocherhans.com>
+    Josh Smeaton <josh.smeaton@gmail.com>
+    Joshua Cannon <joshdcannon@gmail.com>
+    Joshua Ginsberg <jag@flowtheory.net>
+    Jozko Skrablin <jozko.skrablin@gmail.com>
+    J. Pablo Fernandez <pupeno@pupeno.com>
+    jpellerin@gmail.com
+    Juan Catalano <catalanojuan@gmail.com>
+    Juan Manuel Caicedo <juan.manuel.caicedo@gmail.com>
+    Juan Pedro Fisanotti <fisadev@gmail.com>
+    Julia Elman
+    Julia Matsieva <julia.matsieva@gmail.com>
+    Julian Bez
+    Julie Rymer <rymerjulie.pro@gmail.com>
+    Julien Phalip <jphalip@gmail.com>
+    Junyoung Choi <cupjoo@gmail.com>
+    junzhang.jn@gmail.com
+    Jure Cuhalev <gandalf@owca.info>
+    Justin Bronn <jbronn@gmail.com>
+    Justine Tunney <jtunney@gmail.com>
+    Justin Lilly <justinlilly@gmail.com>
+    Justin Michalicek <jmichalicek@gmail.com>
+    Justin Myles Holmes <justin@slashrootcafe.com>
+    Jyrki Pulliainen <jyrki.pulliainen@gmail.com>
+    Kacper Wolkiewicz <kac.wolkiewicz@gmail.com>
+    Kadesarin Sanjek
+    Kapil Bansal <kapilbansal.gbpecdelhi@gmail.com>
+    Karderio <karderio@gmail.com>
+    Karen Tracey <kmtracey@gmail.com>
+    Karol Sikora <elektrrrus@gmail.com>
+    Katherine “Kati” Michel <kthrnmichel@gmail.com>
+    Kathryn Killebrew <kathryn.killebrew@gmail.com>
+    Katie Miller <katie@sub50.com>
+    Keith Bussell <kbussell@gmail.com>
+    Kenneth Love <kennethlove@gmail.com>
+    Kent Hauser <kent@khauser.net>
+    Keryn Knight <keryn@kerynknight.com>
+    Kevin Grinberg <kevin@kevingrinberg.com>
+    Kevin Kubasik <kevin@kubasik.net>
+    Kevin McConnell <kevin.mcconnell@gmail.com>
+    Kieran Holland <http://www.kieranholland.com>
+    kilian <kilian.cavalotti@lip6.fr>
+    Kim Joon Hwan 김준환 <xncbf12@gmail.com>
+    Kim Soung Ryoul 김성렬 <kimsoungryoul@gmail.com>
+    Klaas van Schelven <klaas@vanschelven.com>
+    knox <christobzr@gmail.com>
+    konrad@gwu.edu
+    Kowito Charoenratchatabhan <kowito@felspar.com>
+    Krišjānis Vaiders <krisjanisvaiders@gmail.com>
+    krzysiek.pawlik@silvermedia.pl
+    Krzysztof Jagiello <me@kjagiello.com>
+    Krzysztof Jurewicz <krzysztof.jurewicz@gmail.com>
+    Krzysztof Kulewski <kulewski@gmail.com>
+    kurtiss@meetro.com
+    Lakin Wecker <lakin@structuredabstraction.com>
+    Lars Yencken <lars.yencken@gmail.com>
+    Lau Bech Lauritzen
+    Laurent Luce <https://www.laurentluce.com/>
+    Laurent Rahuel <laurent.rahuel@gmail.com>
+    lcordier@point45.com
+    Leah Culver <leah.culver@gmail.com>
+    Leandra Finger <leandra.finger@gmail.com>
+    Lee Reilly <lee@leereilly.net>
+    Lee Sanghyuck <shlee322@elab.kr>
+    Leo "hylje" Honkanen <sealage@gmail.com>
+    Leo Shklovskii
+    Leo Soto <leo.soto@gmail.com>
+    lerouxb@gmail.com
+    Lex Berezhny <lex@damoti.com>
+    Liang Feng <hutuworm@gmail.com>
+    Lily Foote
+    limodou
+    Lincoln Smith <lincoln.smith@anu.edu.au>
+    Liu Yijie <007gzs@gmail.com>
+    Loek van Gent <loek@barakken.nl>
+    Loïc Bistuer <loic.bistuer@sixmedia.com>
+    Lowe Thiderman <lowe.thiderman@gmail.com>
+    Luan Pablo <luanpab@gmail.com>
+    Lucas Connors <https://www.revolutiontech.ca/>
+    Luciano Ramalho
+    Lucidiot <lucidiot@brainshit.fr>
+    Ludvig Ericson <ludvig.ericson@gmail.com>
+    Luis C. Berrocal <luis.berrocal.1942@gmail.com>
+    Łukasz Langa <lukasz@langa.pl>
+    Łukasz Rekucki <lrekucki@gmail.com>
+    Luke Granger-Brown <django@lukegb.com>
+    Luke Plant <L.Plant.98@cantab.net>
+    Maciej Fijalkowski
+    Maciej Wiśniowski <pigletto@gmail.com>
+    Mads Jensen <https://github.com/atombrella>
+    Makoto Tsuyuki <mtsuyuki@gmail.com>
+    Malcolm Tredinnick
+    Manav Agarwal <dpsman13016@gmail.com>
+    Manuel Saelices <msaelices@yaco.es>
+    Manuzhai
+    Marc Aymerich Gubern
+    Marc Egli <frog32@me.com>
+    Marcel Telka <marcel@telka.sk>
+    Marcelo Galigniana <marcelogaligniana@gmail.com>
+    Marc Fargas <telenieko@telenieko.com>
+    Marc Garcia <marc.garcia@accopensys.com>
+    Marcin Wróbel
+    Marc Remolt <m.remolt@webmasters.de>
+    Marc Seguí Coll <metarizard@gmail.com>
+    Marc Tamlyn <marc.tamlyn@gmail.com>
+    Marc-Aurèle Brothier <ma.brothier@gmail.com>
+    Marian Andre <django@andre.sk>
+    Marijn Vriens <marijn@metronomo.cl>
+    Mario Gonzalez <gonzalemario@gmail.com>
+    Mariusz Felisiak <felisiak.mariusz@gmail.com>
+    Mark Biggers <biggers@utsl.com>
+    Mark Evans <mark@meltdownlabs.com>
+    Mark Gensler <mark.gensler@protonmail.com>
+    mark@junklight.com
+    Mark Lavin <markdlavin@gmail.com>
+    Mark Sandstrom <mark@deliciouslynerdy.com>
+    Markus Amalthea Magnuson <markus.magnuson@gmail.com>
+    Markus Holtermann <https://markusholtermann.eu>
+    Marten Kenbeek <marten.knbk+django@gmail.com>
+    Marti Raudsepp <marti@juffo.org>
+    martin.glueck@gmail.com
+    Martin Green
+    Martin Kosír <martin@martinkosir.net>
+    Martin Mahner <https://www.mahner.org/>
+    Martin Maney <http://www.chipy.org/Martin_Maney>
+    Martin von Gagern <gagern@google.com>
+    Mart Sõmermaa <https://github.com/mrts>
+    Marty Alchin <gulopine@gamemusic.org>
+    Masashi Shibata <m.shibata1020@gmail.com>
+    masonsimon+django@gmail.com
+    Massimiliano Ravelli <massimiliano.ravelli@gmail.com>
+    Massimo Scamarcia <massimo.scamarcia@gmail.com>
+    Mathieu Agopian <mathieu.agopian@gmail.com>
+    Matías Bordese
+    Matt Boersma <matt@sprout.org>
+    Matt Brewer <matt.brewer693@gmail.com>
+    Matt Croydon <http://www.postneo.com/>
+    Matt Deacalion Stevens <matt@dirtymonkey.co.uk>
+    Matt Dennenbaum
+    Matthew Flanagan <https://wadofstuff.blogspot.com/>
+    Matthew Schinckel <matt@schinckel.net>
+    Matthew Somerville <matthew-django@dracos.co.uk>
+    Matthew Tretter <m@tthewwithanm.com>
+    Matthew Wilkes <matt@matthewwilkes.name>
+    Matthias Kestenholz <mk@406.ch>
+    Matthias Pronk <django@masida.nl>
+    Matt Hoskins <skaffenuk@googlemail.com>
+    Matt McClanahan <https://mmcc.cx/>
+    Matt Riggott
+    Matt Robenolt <m@robenolt.com>
+    Mattia Larentis <mattia@laretis.eu>
+    Mattia Procopio <promat85@gmail.com>
+    Mattias Loverot <mattias@stubin.se>
+    mattycakes@gmail.com
+    Max Burstein <http://maxburstein.com>
+    Max Derkachev <mderk@yandex.ru>
+    Max Smolens <msmolens@gmail.com>
+    Maxime Lorant <maxime.lorant@gmail.com>
+    Maxime Turcotte <maxocub@riseup.net>
+    Maximilian Merz <django@mxmerz.de>
+    Maximillian Dornseif <md@hudora.de>
+    mccutchen@gmail.com
+    Meghana Bhange <meghanabhange13@gmail.com>
+    Meir Kriheli <http://mksoft.co.il/>
+    Michael S. Brown <michael@msbrown.net>
+    Michael Hall <mhall1@ualberta.ca>
+    Michael Josephson <http://www.sdjournal.com/>
+    Michael Lissner <mike@free.law>
+    Michael Manfre <mmanfre@gmail.com>
+    michael.mcewan@gmail.com
+    Michael Placentra II <someone@michaelplacentra2.net>
+    Michael Radziej <mir@noris.de>
+    Michael Sanders <m.r.sanders@gmail.com>
+    Michael Schwarz <michi.schwarz@gmail.com>
+    Michael Sinov <sihaelov@gmail.com>
+    Michael Thornhill <michael.thornhill@gmail.com>
+    Michal Chruszcz <troll@pld-linux.org>
+    michal@plovarna.cz
+    Michał Modzelewski <michal.modzelewski@gmail.com>
+    Mihai Damian <yang_damian@yahoo.com>
+    Mihai Preda <mihai_preda@yahoo.com>
+    Mikaël Barbero <mikael.barbero nospam at nospam free.fr>
+    Mike Axiak <axiak@mit.edu>
+    Mike Grouchy <https://mikegrouchy.com/>
+    Mike Malone <mjmalone@gmail.com>
+    Mike Richardson
+    Mike Wiacek <mjwiacek@google.com>
+    Mikhail Korobov <kmike84@googlemail.com>
+    Mikko Hellsing <mikko@sorl.net>
+    Mikołaj Siedlarek <mikolaj.siedlarek@gmail.com>
+    milkomeda
+    Milton Waddams
+    mitakummaa@gmail.com
+    mmarshall
+    Moayad Mardini <moayad.m@gmail.com>
+    Morgan Aubert <morgan.aubert@zoho.com>
+    Moritz Sichert <moritz.sichert@googlemail.com>
+    Morten Bagai <m@bagai.com>
+    msaelices <msaelices@gmail.com>
+    msundstr
+    Mushtaq Ali <mushtaak@gmail.com>
+    Mykola Zamkovoi <nickzam@gmail.com>
+    Nadège Michel <michel.nadege@gmail.com>
+    Nagy Károly <charlie@rendszergazda.com>
+    Nasimul Haque <nasim.haque@gmail.com>
+    Nasir Hussain <nasirhjafri@gmail.com>
+    Natalia Bidart <nataliabidart@gmail.com>
+    Nate Bragg <jonathan.bragg@alum.rpi.edu>
+    Nathan Gaberel <nathan@gnab.fr>
+    Neal Norwitz <nnorwitz@google.com>
+    Nebojša Dorđević
+    Ned Batchelder <https://nedbatchelder.com/>
+    Nena Kojadin <nena@kiberpipa.org>
+    Niall Dalton <niall.dalton12@gmail.com>
+    Niall Kelly <duke.sam.vimes@gmail.com>
+    Nick Efford <nick@efford.org>
+    Nick Lane <nick.lane.au@gmail.com>
+    Nick Pope <nick@nickpope.me.uk>
+    Nick Presta <nick@nickpresta.ca>
+    Nick Sandford <nick.sandford@gmail.com>
+    Nick Sarbicki <nick.a.sarbicki@gmail.com>
+    Niclas Olofsson <n@niclasolofsson.se>
+    Nicola Larosa <nico@teknico.net>
+    Nicolas Lara <nicolaslara@gmail.com>
+    Nicolas Noé <nicolas@niconoe.eu>
+    Nikita Marchant <nikita.marchant@gmail.com>
+    Nikita Sobolev <mail@sobolevn.me>
+    Niran Babalola <niran@niran.org>
+    Nis Jørgensen <nis@superlativ.dk>
+    Nowell Strite <https://nowell.strite.org/>
+    Nuno Mariz <nmariz@gmail.com>
+    Octavio Peri <octaperi@gmail.com>
+    oggie rob <oz.robharvey@gmail.com>
+    oggy <ognjen.maric@gmail.com>
+    Oliver Beattie <oliver@obeattie.com>
+    Oliver Rutherfurd <http://rutherfurd.net/>
+    Olivier Le Thanh Duong <olivier@lethanh.be>
+    Olivier Sels <olivier.sels@gmail.com>
+    Olivier Tabone <olivier.tabone@ripplemotion.fr>
+    Orestis Markou <orestis@orestis.gr>
+    Orne Brocaar <http://brocaar.com/>
+    Oscar Ramirez <tuxskar@gmail.com>
+    Ossama M. Khayat <okhayat@yahoo.com>
+    Owen Griffiths
+    Ömer Faruk Abacı <https://github.com/omerfarukabaci/>
+    Pablo Martín <goinnn@gmail.com>
+    Panos Laganakos <panos.laganakos@gmail.com>
+    Paolo Melchiorre <paolo@melchiorre.org>
+    Pascal Hartig <phartig@rdrei.net>
+    Pascal Varet
+    Patrik Sletmo <patrik.sletmo@gmail.com>
+    Paul Bissex <http://e-scribe.com/>
+    Paul Collier <paul@paul-collier.com>
+    Paul Collins <paul.collins.iii@gmail.com>
+    Paul Donohue <django@PaulSD.com>
+    Paul Lanier <planier@google.com>
+    Paul McLanahan <paul@mclanahan.net>
+    Paul McMillan <Paul@McMillan.ws>
+    Paulo Poiati <paulogpoiati@gmail.com>
+    Paulo Scardine <paulo@scardine.com.br>
+    Paul Smith <blinkylights23@gmail.com>
+    Pavel Kulikov <kulikovpavel@gmail.com>
+    pavithran s <pavithran.s@gmail.com>
+    Pavlo Kapyshin <i@93z.org>
+    permonik@mesias.brnonet.cz
+    Petar Marić <http://www.petarmaric.com/>
+    Pete Crosier <pete.crosier@gmail.com>
+    peter@mymart.com
+    Peter Sheats <sheats@gmail.com>
+    Peter van Kampen
+    Peter Zsoldos <http://zsoldosp.eu>
+    Pete Shinners <pete@shinners.org>
+    Petr Marhoun <petr.marhoun@gmail.com>
+    Petter Strandmark
+    pgross@thoughtworks.com
+    phaedo <http://phaedo.cx/>
+    phil.h.smith@gmail.com
+    Philip Lindborg <philip.lindborg@gmail.com>
+    Philippe Raoult <philippe.raoult@n2nsoft.com>
+    phil@produxion.net
+    Piotr Jakimiak <piotr.jakimiak@gmail.com>
+    Piotr Lewandowski <piotr.lewandowski@gmail.com>
+    plisk
+    polpak@yahoo.com
+    pradeep.gowda@gmail.com
+    Preston Holmes <preston@ptone.com>
+    Preston Timmons <prestontimmons@gmail.com>
+    Priyansh Saxena <askpriyansh@gmail.com>
+    Przemysław Buczkowski <przemub@przemub.pl>
+    Przemysław Suliga <http://suligap.net>
+    Qi Zhao <zhaoqi99@outlook.com>
+    Rachel Tobin <rmtobin@me.com>
+    Rachel Willmer <http://www.willmer.com/kb/>
+    Radek Švarz <https://www.svarz.cz/translate/>
+    Rafael Giebisch <rafael@giebisch-mail.de>
+    Raffaele Salmaso <raffaele@salmaso.org>
+    Rahmat Faisal <mad.skidipap@gmail.com>
+    Rajesh Dhawan <rajesh.dhawan@gmail.com>
+    Ramez Ashraf <ramezashraf@gmail.com>
+    Ramil Yanbulatov <rayman1104@gmail.com>
+    Ramin Farajpour Cami <ramin.blackhat@gmail.com>
+    Ramiro Morales <ramiro@rmorales.net>
+    Ramon Saraiva <ramonsaraiva@gmail.com>
+    Ram Rachum <ram@rachum.com>
+    Randy Barlow <randy@electronsweatshop.com>
+    Raphaël Barrois <raphael.barrois@m4x.org>
+    Raphael Michel <mail@raphaelmichel.de>
+    Raúl Cumplido <raulcumplido@gmail.com>
+    Rebecca Smith <rebkwok@gmail.com>
+    Remco Wendt <remco.wendt@gmail.com>
+    Renaud Parent <renaud.parent@gmail.com>
+    Renbi Yu <averybigant@gmail.com>
+    Reza Mohammadi <reza@zeerak.ir>
+    rhettg@gmail.com
+    Ricardo Javier Cárdenes Medina <ricardo.cardenes@gmail.com>
+    ricardojbarrios@gmail.com
+    Riccardo Di Virgilio
+    Riccardo Magliocchetti <riccardo.magliocchetti@gmail.com>
+    Richard Davies <richard.davies@elastichosts.com>
+    Richard House <Richard.House@i-logue.com>
+    Rick Wagner <rwagner@physics.ucsd.edu>
+    Rigel Di Scala <rigel.discala@propylon.com>
+    Robert Coup
+    Robert Myers <myer0052@gmail.com>
+    Roberto Aguilar <roberto@baremetal.io>
+    Robert Rock Howard <http://djangomojo.com/>
+    Robert Wittams
+    Rob Golding-Day <rob@golding-day.com>
+    Rob Hudson <https://rob.cogit8.org/>
+    Rob Nguyen <tienrobertnguyenn@gmail.com>
+    Robin Munn <http://www.geekforgod.com/>
+    Rodrigo Pinheiro Marques de Araújo <fenrrir@gmail.com>
+    Rohith P R <https://rohithpr.com>
+    Romain Garrigues <romain.garrigues.cs@gmail.com>
+    Ronnie van den Crommenacker
+    Ronny Haryanto <https://ronny.haryan.to/>
+    Ross Poulton <ross@rossp.org>
+    Roxane Bellot <https://github.com/roxanebellot/>
+    Rozza <ross.lawley@gmail.com>
+    Rudolph Froger <rfroger@estrate.nl>
+    Rudy Mutter
+    Rune Rønde Laursen <runerl@skjoldhoej.dk>
+    Russell Cloran <russell@rucus.net>
+    Russell Keith-Magee <russell@keith-magee.com>
+    Russ Webber
+    Ryan Hall <ryanhall989@gmail.com>
+    Ryan Heard <ryanwheard@gmail.com>
+    ryankanno
+    Ryan Kelly <ryan@rfk.id.au>
+    Ryan Niemeyer <https://profiles.google.com/ryan.niemeyer/about>
+    Ryan Petrello <ryan@ryanpetrello.com>
+    Ryan Rubin <ryanmrubin@gmail.com>
+    Ryno Mathee <rmathee@gmail.com>
+    Sachin Jat <sanch.jat@gmail.com>
+    Sage M. Abdullah <https://github.com/laymonage>
+    Sam Newman <http://www.magpiebrain.com/>
+    Sander Dijkhuis <sander.dijkhuis@gmail.com>
+    Sanket Saurav <sanketsaurav@gmail.com>
+    Sanyam Khurana <sanyam.khurana01@gmail.com>
+    Sarah Boyce <https://github.com/sarahboyce>
+    Sarthak Mehrish <sarthakmeh03@gmail.com>
+    schwank@gmail.com
+    Scot Hacker <shacker@birdhouse.org>
+    Scott Barr <scott@divisionbyzero.com.au>
+    Scott Cranfill <scott@scottcranfill.com>
+    Scott Fitsimones <scott@airgara.ge>
+    Scott Pashley <github@scottpashley.co.uk>
+    scott@staplefish.com
+    Sean Brant
+    Sebastian Hillig <sebastian.hillig@gmail.com>
+    Sebastian Spiegel <https://www.tivix.com/>
+    Segyo Myung <myungsekyo@gmail.com>
+    Selwin Ong <selwin@ui.co.id>
+    Sengtha Chay <sengtha@e-khmer.com>
+    Senko Rašić <senko.rasic@dobarkod.hr>
+    serbaut@gmail.com
+    Sergei Maertens <sergeimaertens@gmail.com>
+    Sergey Fedoseev <fedoseev.sergey@gmail.com>
+    Sergey Kolosov <m17.admin@gmail.com>
+    Seth Hill <sethrh@gmail.com>
+    Shai Berger <shai@platonix.com>
+    Shannon -jj Behrens <https://www.jjinux.com/>
+    Shawn Milochik <shawn@milochik.com>
+    Shreya Bamne <shreya.bamne@gmail.com>
+    Silvan Spross <silvan.spross@gmail.com>
+    Simeon Visser <http://simeonvisser.com>
+    Simon Blanchard
+    Simon Charette <charette.s@gmail.com>
+    Simon Greenhill <dev@simon.net.nz>
+    Simon Litchfield <simon@quo.com.au>
+    Simon Meers <simon@simonmeers.com>
+    Simon Williams
+    Simon Willison <simon@simonwillison.net>
+    Sjoerd Job Postmus
+    Slawek Mikula <slawek dot mikula at gmail dot com>
+    sloonz <simon.lipp@insa-lyon.fr>
+    smurf@smurf.noris.de
+    sopel
+    Sreehari K V <sreeharivijayan619@gmail.com>
+    Sridhar Marella <sridhar562345@gmail.com>
+    Srinivas Reddy Thatiparthy <thatiparthysreenivas@gmail.com>
+    Stanislas Guerra <stan@slashdev.me>
+    Stanislaus Madueke
+    Stanislav Karpov <work@stkrp.ru>
+    starrynight <cmorgh@gmail.com>
+    Stefan R. Filipek
+    Stefane Fermgier <sf@fermigier.com>
+    Stefano Rivera <stefano@rivera.za.net>
+    Stéphane Raimbault <stephane.raimbault@gmail.com>
+    Stephan Jaekel <steph@rdev.info>
+    Stephen Burrows <stephen.r.burrows@gmail.com>
+    Steven L. Smith (fvox13) <steven@stevenlsmith.com>
+    Steven Noorbergen (Xaroth) <xaroth+django@xaroth.nl>
+    Stuart Langridge <https://www.kryogenix.org/>
+    Subhav Gautam <subhavgautam@yahoo.co.uk>
+    Sujay S Kumar <sujay.skumar141295@gmail.com>
+    Sune Kirkeby <https://ibofobi.dk/>
+    Sung-Jin Hong <serialx.net@gmail.com>
+    SuperJared
+    Susan Tan <susan.tan.fleckerl@gmail.com>
+    Sutrisno Efendi <kangfend@gmail.com>
+    Swaroop C H <http://www.swaroopch.info>
+    Szilveszter Farkas <szilveszter.farkas@gmail.com>
+    Taavi Teska <taaviteska@gmail.com>
+    Tai Lee <real.human@mrmachine.net>
+    Takashi Matsuo <matsuo.takashi@gmail.com>
+    Tareque Hossain <http://www.codexn.com>
+    Taylor Mitchell <taylor.mitchell@gmail.com>
+    Terry Huang <terryh.tp@gmail.com>
+    thebjorn <bp@datakortet.no>
+    Thejaswi Puthraya <thejaswi.puthraya@gmail.com>
+    Thijs van Dien <thijs@vandien.net>
+    Thom Wiggers
+    Thomas Chaumeny <t.chaumeny@gmail.com>
+    Thomas Güttler <hv@tbz-pariv.de>
+    Thomas Kerpe <thomas@kerpe.net>
+    Thomas Sorrel
+    Thomas Steinacher <http://www.eggdrop.ch/>
+    Thomas Stromberg <tstromberg@google.com>
+    Thomas Tanner <tanner@gmx.net>
+    tibimicu@gmx.net
+    Ties Jan Hefting <hello@tiesjan.com>
+    Tim Allen <tim@pyphilly.org>
+    Tim Givois <tim.givois.mendez@gmail.com>
+    Tim Graham <timograham@gmail.com>
+    Tim Heap <tim@timheap.me>
+    Tim McCurrach <tim.mccurrach@gmail.com>
+    Tim Saylor <tim.saylor@gmail.com>
+    Tobias Kunze <rixx@cutebit.de>
+    Tobias McNulty <https://www.caktusgroup.com/blog/>
+    tobias@neuyork.de
+    Todd O'Bryan <toddobryan@mac.com>
+    Tom Carrick <https://www.carrick.eu>
+    Tom Christie <tom@tomchristie.com>
+    Tom Forbes <tom@tomforb.es>
+    Tom Insam
+    Tom Tobin
+    Tom Wojcik <me@tomwojcik.com>
+    Tomáš Ehrlich <tomas.ehrlich@gmail.com>
+    Tomáš Kopeček <permonik@m6.cz>
+    Tome Cvitan <tome@cvitan.com>
+    Tomek Paczkowski <tomek@hauru.eu>
+    Tomer Chachamu
+    Tommy Beadle <tbeadle@gmail.com>
+    Tore Lundqvist <tore.lundqvist@gmail.com>
+    torne-django@wolfpuppy.org.uk
+    Travis Cline <travis.cline@gmail.com>
+    Travis Pinney
+    Travis Swicegood <travis@domain51.com>
+    Travis Terry <tdterry7@gmail.com>
+    Trevor Caira <trevor@caira.com>
+    Trey Long <trey@ktrl.com>
+    tstromberg@google.com
+    tt@gurgle.no
+    Tyler Tarabula <tyler.tarabula@gmail.com>
+    Tyson Clugg <tyson@clugg.net>
+    Tyson Tate <tyson@fallingbullets.com>
+    Unai Zalakain <unai@gisa-elkartea.org>
+    Valentina Mukhamedzhanova <umirra@gmail.com>
+    valtron
+    Vasiliy Stavenko <stavenko@gmail.com>
+    Vasil Vangelovski
+    Vibhu Agarwal <vibhu-agarwal.github.io>
+    Victor Andrée
+    viestards.lists@gmail.com
+    Viktor Danyliuk <v.v.danyliuk@gmail.com>
+    Viktor Grabov <viktor@grabov.ru>
+    Ville Säävuori <https://www.unessa.net/>
+    Vinay Karanam <https://github.com/vinayinvicible>
+    Vinay Sajip <vinay_sajip@yahoo.co.uk>
+    Vincent Foley <vfoleybourgon@yahoo.ca>
+    Vinny Do <vdo.code@gmail.com>
+    Vitaly Babiy <vbabiy86@gmail.com>
+    Vitaliy Yelnik <velnik@gmail.com>
+    Vladimir Kuzma <vladimirkuzma.ch@gmail.com>
+    Vlado <vlado@labath.org>
+    Vsevolod Solovyov
+    Vytis Banaitis <vytis.banaitis@gmail.com>
+    wam-djangobug@wamber.net
+    Wang Chun <wangchun@exoweb.net>
+    Warren Smith <warren@wandrsmith.net>
+    Waylan Limberg <waylan@gmail.com>
+    Wiktor Kołodziej <wiktor@pykonik.org>
+    Wiley Kestner <wiley.kestner@gmail.com>
+    Wiliam Alves de Souza <wiliamsouza83@gmail.com>
+    Will Ayd <william.ayd@icloud.com>
+    William Schwartz <wkschwartz@gmail.com>
+    Will Hardy <django@willhardy.com.au>
+    Wilson Miner <wminer@gmail.com>
+    Wim Glenn <hey@wimglenn.com>
+    wojtek
+    Wu Haotian <whtsky@gmail.com>
+    Xavier Francisco <xavier.n.francisco@gmail.com>
+    Xia Kai <https://blog.xiaket.org/>
+    Yann Fouillat <gagaro42@gmail.com>
+    Yann Malet
+    Yash Jhunjhunwala
+    Yasushi Masuda <whosaysni@gmail.com>
+    ye7cakf02@sneakemail.com
+    ymasuda@ethercube.com
+    Yoong Kang Lim <yoongkang.lim@gmail.com>
+    Yusuke Miyazaki <miyazaki.dev@gmail.com>
+    yyyyyyyan <contact@yyyyyyyan.tech>
+    Zac Hatfield-Dodds <zac.hatfield.dodds@gmail.com>
+    Zachary Voase <zacharyvoase@gmail.com>
+    Zach Liu <zachliu@gmail.com>
+    Zach Thompson <zthompson47@gmail.com>
+    Zain Memon
+    Zain Patel <zain.patel06@gmail.com>
+    Zak Johnson <zakj@nox.cx>
+    Žan Anderle <zan.anderle@gmail.com>
+    Zbigniew Siciarz <zbigniew@siciarz.net>
+    zegor
+    Zeynel Özdemir <ozdemir.zynl@gmail.com>
+    Zlatko Mašek <zlatko.masek@gmail.com>
+    zriv <https://github.com/zriv>
+    <Please alphabetize new entries>
+
+A big THANK YOU goes to:
+
+    Rob Curley and Ralph Gage for letting us open-source Django.
+
+    Frank Wiles for making excellent arguments for open-sourcing, and for
+    his sage sysadmin advice.
+
+    Ian Bicking for convincing Adrian to ditch code generation.
+
+    Mark Pilgrim for "Dive Into Python" (https://www.diveinto.org/python3/).
+
+    Guido van Rossum for creating Python.

testbed/django__django/CONTRIBUTING.rst

@@ -0,0 +1,32 @@
+======================
+Contributing to Django
+======================
+
+As an open source project, Django welcomes contributions of many forms.
+
+Examples of contributions include:
+
+* Code patches
+* Documentation improvements
+* Bug reports and patch reviews
+
+Extensive contribution guidelines are available in the repository at
+``docs/internals/contributing/``, or online at:
+
+https://docs.djangoproject.com/en/dev/internals/contributing/
+
+**Warning: non-trivial pull requests (anything more than fixing a typo) without
+Trac tickets will be closed!** `Please file a ticket`__ to suggest changes.
+
+__ https://code.djangoproject.com/newticket
+
+Django uses Trac to keep track of bugs, feature requests, and associated
+patches because GitHub doesn't provide adequate tooling for its community.
+Patches can be submitted as pull requests, but if you don't file a ticket,
+it's unlikely that we'll notice your contribution.
+
+Code of Conduct
+===============
+
+As a contributor, you can help us keep the Django community open and inclusive.
+Please read and follow our `Code of Conduct <https://www.djangoproject.com/conduct/>`_.

testbed/django__django/Gruntfile.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const globalThreshold = 50; // Global code coverage threshold (as a percentage)
+
+module.exports = function(grunt) {
+    grunt.initConfig({
+        qunit: {
+            all: ['js_tests/tests.html']
+        }
+    });
+
+    grunt.loadNpmTasks('grunt-contrib-qunit');
+    grunt.registerTask('test', ['qunit']);
+    grunt.registerTask('default', ['test']);
+};

testbed/django__django/INSTALL

@@ -0,0 +1,8 @@
+Thanks for downloading Django.
+
+To install it, make sure you have Python 3.10 or greater installed. Then run
+this command from the command prompt:
+
+    python -m pip install .
+
+For more detailed instructions, see docs/intro/install.txt.

testbed/django__django/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) Django Software Foundation and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of Django nor the names of its contributors may be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

testbed/django__django/LICENSE.python

@@ -0,0 +1,290 @@
+Django is licensed under the three-clause BSD license; see the file
+LICENSE for details.
+
+Django includes code from the Python standard library, which is licensed under
+the Python license, a permissive open source license. The copyright and license
+is included below for compliance with Python's terms.
+
+----------------------------------------------------------------------
+
+Copyright (c) 2001-present Python Software Foundation; All Rights Reserved
+
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2 and above   2.1.1       2001-now    PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+Python software and documentation are licensed under the
+Python Software Foundation License Version 2.
+
+Starting with Python 3.8.6, examples, recipes, and other code in
+the documentation are dual licensed under the PSF License Version 2
+and the Zero-Clause BSD license.
+
+Some software incorporated into Python is under different licenses.
+The licenses are listed with code falling under that license.
+
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+----------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

testbed/django__django/MANIFEST.in

@@ -0,0 +1,17 @@
+include AUTHORS
+include Gruntfile.js
+include INSTALL
+include LICENSE
+include LICENSE.python
+include MANIFEST.in
+include package.json
+include tox.ini
+include *.rst
+graft django
+graft docs
+graft extras
+graft js_tests
+graft scripts
+graft tests
+global-exclude __pycache__
+global-exclude *.py[co]

testbed/django__django/README.rst

@@ -0,0 +1,58 @@
+======
+Django
+======
+
+Django is a high-level Python web framework that encourages rapid development
+and clean, pragmatic design. Thanks for checking it out.
+
+All documentation is in the "``docs``" directory and online at
+https://docs.djangoproject.com/en/stable/. If you're just getting started,
+here's how we recommend you read the docs:
+
+* First, read ``docs/intro/install.txt`` for instructions on installing Django.
+
+* Next, work through the tutorials in order (``docs/intro/tutorial01.txt``,
+  ``docs/intro/tutorial02.txt``, etc.).
+
+* If you want to set up an actual deployment server, read
+  ``docs/howto/deployment/index.txt`` for instructions.
+
+* You'll probably want to read through the topical guides (in ``docs/topics``)
+  next; from there you can jump to the HOWTOs (in ``docs/howto``) for specific
+  problems, and check out the reference (``docs/ref``) for gory details.
+
+* See ``docs/README`` for instructions on building an HTML version of the docs.
+
+Docs are updated rigorously. If you find any problems in the docs, or think
+they should be clarified in any way, please take 30 seconds to fill out a
+ticket here: https://code.djangoproject.com/newticket
+
+To get more help:
+
+* Join the ``#django`` channel on ``irc.libera.chat``. Lots of helpful people
+  hang out there. `Webchat is available <https://web.libera.chat/#django>`_.
+
+* Join the django-users mailing list, or read the archives, at
+  https://groups.google.com/group/django-users.
+
+* Join the `Django Discord community <https://discord.gg/xcRH6mN4fa>`_.
+
+* Join the community on the `Django Forum <https://forum.djangoproject.com/>`_.
+
+To contribute to Django:
+
+* Check out https://docs.djangoproject.com/en/dev/internals/contributing/ for
+  information about getting involved.
+
+To run Django's test suite:
+
+* Follow the instructions in the "Unit tests" section of
+  ``docs/internals/contributing/writing-code/unit-tests.txt``, published online at
+  https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/unit-tests/#running-the-unit-tests
+
+Supporting the Development of Django
+====================================
+
+Django's development depends on your contributions.
+
+If you depend on Django, remember to support the Django Software Foundation: https://www.djangoproject.com/fundraising/

testbed/django__django/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "Django",
+  "private": true,
+  "scripts": {
+    "pretest": "eslint .",
+    "test": "grunt test --verbose"
+  },
+  "engines": {
+    "npm": ">=1.3.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.44.0",
+    "puppeteer": "^19.11.1",
+    "grunt": "^1.6.1",
+    "grunt-cli": "^1.4.3",
+    "grunt-contrib-qunit": "^7.0.0",
+    "qunit": "^2.19.4"
+  }
+}

testbed/django__django/pyproject.toml

@@ -0,0 +1,7 @@
+[build-system]
+requires = ['setuptools>=40.8.0']
+build-backend = 'setuptools.build_meta'
+
+[tool.black]
+target-version = ['py310']
+force-exclude = 'tests/test_runner_apps/tagged/tests_syntax_error.py'

testbed/django__django/setup.cfg

@@ -0,0 +1,69 @@
+[metadata]
+name = Django
+version = attr: django.__version__
+url = https://www.djangoproject.com/
+author = Django Software Foundation
+author_email = foundation@djangoproject.com
+description = A high-level Python web framework that encourages rapid development and clean, pragmatic design.
+long_description = file: README.rst
+license = BSD-3-Clause
+classifiers =
+    Development Status :: 2 - Pre-Alpha
+    Environment :: Web Environment
+    Framework :: Django
+    Intended Audience :: Developers
+    License :: OSI Approved :: BSD License
+    Operating System :: OS Independent
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3 :: Only
+    Programming Language :: Python :: 3.10
+    Programming Language :: Python :: 3.11
+    Topic :: Internet :: WWW/HTTP
+    Topic :: Internet :: WWW/HTTP :: Dynamic Content
+    Topic :: Internet :: WWW/HTTP :: WSGI
+    Topic :: Software Development :: Libraries :: Application Frameworks
+    Topic :: Software Development :: Libraries :: Python Modules
+project_urls =
+    Documentation = https://docs.djangoproject.com/
+    Release notes = https://docs.djangoproject.com/en/stable/releases/
+    Funding = https://www.djangoproject.com/fundraising/
+    Source = https://github.com/django/django
+    Tracker = https://code.djangoproject.com/
+
+[options]
+python_requires = >=3.10
+packages = find:
+include_package_data = true
+zip_safe = false
+install_requires =
+    asgiref >= 3.7.0
+    sqlparse >= 0.3.1
+    tzdata; sys_platform == 'win32'
+
+[options.entry_points]
+console_scripts =
+    django-admin = django.core.management:execute_from_command_line
+
+[options.extras_require]
+argon2 = argon2-cffi >= 19.1.0
+bcrypt = bcrypt
+
+[bdist_rpm]
+doc_files = docs extras AUTHORS INSTALL LICENSE README.rst
+install_script = scripts/rpm-install.sh
+
+[flake8]
+exclude = build,.git,.tox,./tests/.env
+extend-ignore = E203
+max-line-length = 88
+per-file-ignores =
+    django/core/cache/backends/filebased.py:W601
+    django/core/cache/backends/base.py:W601
+    django/core/cache/backends/redis.py:W601
+    tests/cache/tests.py:W601
+
+[isort]
+profile = black
+default_section = THIRDPARTY
+known_first_party = django

testbed/django__django/setup.py

@@ -0,0 +1,55 @@
+import os
+import site
+import sys
+from distutils.sysconfig import get_python_lib
+
+from setuptools import setup
+
+# Allow editable install into user site directory.
+# See https://github.com/pypa/pip/issues/7953.
+site.ENABLE_USER_SITE = "--user" in sys.argv[1:]
+
+# Warn if we are installing over top of an existing installation. This can
+# cause issues where files that were deleted from a more recent Django are
+# still present in site-packages. See #18115.
+overlay_warning = False
+if "install" in sys.argv:
+    lib_paths = [get_python_lib()]
+    if lib_paths[0].startswith("/usr/lib/"):
+        # We have to try also with an explicit prefix of /usr/local in order to
+        # catch Debian's custom user site-packages directory.
+        lib_paths.append(get_python_lib(prefix="/usr/local"))
+    for lib_path in lib_paths:
+        existing_path = os.path.abspath(os.path.join(lib_path, "django"))
+        if os.path.exists(existing_path):
+            # We note the need for the warning here, but present it after the
+            # command is run, so it's more likely to be seen.
+            overlay_warning = True
+            break
+
+
+setup()
+
+
+if overlay_warning:
+    sys.stderr.write(
+        """
+
+========
+WARNING!
+========
+
+You have just installed Django over top of an existing
+installation, without removing it first. Because of this,
+your install may now include extraneous files from a
+previous version that have since been removed from
+Django. This is known to cause a variety of problems. You
+should manually remove the
+
+%(existing_path)s
+
+directory and re-install Django.
+
+"""
+        % {"existing_path": existing_path}
+    )

testbed/django__django/tests/.coveragerc

@@ -0,0 +1,16 @@
+[run]
+branch = True
+concurrency = multiprocessing,thread
+data_file = .coverages/.coverage
+omit =
+    */django/utils/autoreload.py
+source = django
+
+[report]
+ignore_errors = True
+omit =
+    */django/conf/locale/*
+    */tests/*
+
+[html]
+directory = coverage_html

testbed/django__django/tests/README.rst

@@ -0,0 +1,10 @@
+To run the test suite, first, create and activate a virtual environment. Then
+install some requirements and run the tests::
+
+    $ cd tests
+    $ python -m pip install -e ..
+    $ python -m pip install -r requirements/py3.txt
+    $ ./runtests.py
+
+For more information about the test suite, see
+https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/unit-tests/.

testbed/django__django/tests/model_fields/test_field_flags.py

@@ -0,0 +1,221 @@
+from django import test
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
+from django.db import models
+
+from .models import AllFieldsModel
+
+NON_CONCRETE_FIELDS = (
+    models.ForeignObject,
+    GenericForeignKey,
+    GenericRelation,
+)
+
+NON_EDITABLE_FIELDS = (
+    models.BinaryField,
+    GenericForeignKey,
+    GenericRelation,
+)
+
+RELATION_FIELDS = (
+    models.ForeignKey,
+    models.ForeignObject,
+    models.ManyToManyField,
+    models.OneToOneField,
+    GenericForeignKey,
+    GenericRelation,
+)
+
+MANY_TO_MANY_CLASSES = {
+    models.ManyToManyField,
+}
+
+MANY_TO_ONE_CLASSES = {
+    models.ForeignObject,
+    models.ForeignKey,
+    GenericForeignKey,
+}
+
+ONE_TO_MANY_CLASSES = {
+    models.ForeignObjectRel,
+    models.ManyToOneRel,
+    GenericRelation,
+}
+
+ONE_TO_ONE_CLASSES = {
+    models.OneToOneField,
+}
+
+FLAG_PROPERTIES = (
+    "concrete",
+    "editable",
+    "is_relation",
+    "model",
+    "hidden",
+    "one_to_many",
+    "many_to_one",
+    "many_to_many",
+    "one_to_one",
+    "related_model",
+)
+
+FLAG_PROPERTIES_FOR_RELATIONS = (
+    "one_to_many",
+    "many_to_one",
+    "many_to_many",
+    "one_to_one",
+)
+
+
+class FieldFlagsTests(test.SimpleTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.fields = [
+            *AllFieldsModel._meta.fields,
+            *AllFieldsModel._meta.private_fields,
+        ]
+
+        cls.all_fields = [
+            *cls.fields,
+            *AllFieldsModel._meta.many_to_many,
+            *AllFieldsModel._meta.private_fields,
+        ]
+
+        cls.fields_and_reverse_objects = [
+            *cls.all_fields,
+            *AllFieldsModel._meta.related_objects,
+        ]
+
+    def test_each_field_should_have_a_concrete_attribute(self):
+        self.assertTrue(all(f.concrete.__class__ == bool for f in self.fields))
+
+    def test_each_field_should_have_an_editable_attribute(self):
+        self.assertTrue(all(f.editable.__class__ == bool for f in self.all_fields))
+
+    def test_each_field_should_have_a_has_rel_attribute(self):
+        self.assertTrue(all(f.is_relation.__class__ == bool for f in self.all_fields))
+
+    def test_each_object_should_have_auto_created(self):
+        self.assertTrue(
+            all(
+                f.auto_created.__class__ == bool
+                for f in self.fields_and_reverse_objects
+            )
+        )
+
+    def test_non_concrete_fields(self):
+        for field in self.fields:
+            if type(field) in NON_CONCRETE_FIELDS:
+                self.assertFalse(field.concrete)
+            else:
+                self.assertTrue(field.concrete)
+
+    def test_non_editable_fields(self):
+        for field in self.all_fields:
+            if type(field) in NON_EDITABLE_FIELDS:
+                self.assertFalse(field.editable)
+            else:
+                self.assertTrue(field.editable)
+
+    def test_related_fields(self):
+        for field in self.all_fields:
+            if type(field) in RELATION_FIELDS:
+                self.assertTrue(field.is_relation)
+            else:
+                self.assertFalse(field.is_relation)
+
+    def test_field_names_should_always_be_available(self):
+        for field in self.fields_and_reverse_objects:
+            self.assertTrue(field.name)
+
+    def test_all_field_types_should_have_flags(self):
+        for field in self.fields_and_reverse_objects:
+            for flag in FLAG_PROPERTIES:
+                self.assertTrue(
+                    hasattr(field, flag),
+                    "Field %s does not have flag %s" % (field, flag),
+                )
+            if field.is_relation:
+                true_cardinality_flags = sum(
+                    getattr(field, flag) is True
+                    for flag in FLAG_PROPERTIES_FOR_RELATIONS
+                )
+                # If the field has a relation, there should be only one of the
+                # 4 cardinality flags available.
+                self.assertEqual(1, true_cardinality_flags)
+
+    def test_cardinality_m2m(self):
+        m2m_type_fields = [
+            f for f in self.all_fields if f.is_relation and f.many_to_many
+        ]
+        # Test classes are what we expect
+        self.assertEqual(MANY_TO_MANY_CLASSES, {f.__class__ for f in m2m_type_fields})
+
+        # Ensure all m2m reverses are m2m
+        for field in m2m_type_fields:
+            reverse_field = field.remote_field
+            self.assertTrue(reverse_field.is_relation)
+            self.assertTrue(reverse_field.many_to_many)
+            self.assertTrue(reverse_field.related_model)
+
+    def test_cardinality_o2m(self):
+        o2m_type_fields = [
+            f
+            for f in self.fields_and_reverse_objects
+            if f.is_relation and f.one_to_many
+        ]
+        # Test classes are what we expect
+        self.assertEqual(ONE_TO_MANY_CLASSES, {f.__class__ for f in o2m_type_fields})
+
+        # Ensure all o2m reverses are m2o
+        for field in o2m_type_fields:
+            if field.concrete:
+                reverse_field = field.remote_field
+                self.assertTrue(reverse_field.is_relation and reverse_field.many_to_one)
+
+    def test_cardinality_m2o(self):
+        m2o_type_fields = [
+            f
+            for f in self.fields_and_reverse_objects
+            if f.is_relation and f.many_to_one
+        ]
+        # Test classes are what we expect
+        self.assertEqual(MANY_TO_ONE_CLASSES, {f.__class__ for f in m2o_type_fields})
+
+        # Ensure all m2o reverses are o2m
+        for obj in m2o_type_fields:
+            if hasattr(obj, "field"):
+                reverse_field = obj.field
+                self.assertTrue(reverse_field.is_relation and reverse_field.one_to_many)
+
+    def test_cardinality_o2o(self):
+        o2o_type_fields = [f for f in self.all_fields if f.is_relation and f.one_to_one]
+        # Test classes are what we expect
+        self.assertEqual(ONE_TO_ONE_CLASSES, {f.__class__ for f in o2o_type_fields})
+
+        # Ensure all o2o reverses are o2o
+        for obj in o2o_type_fields:
+            if hasattr(obj, "field"):
+                reverse_field = obj.field
+                self.assertTrue(reverse_field.is_relation and reverse_field.one_to_one)
+
+    def test_hidden_flag(self):
+        incl_hidden = set(AllFieldsModel._meta.get_fields(include_hidden=True))
+        no_hidden = set(AllFieldsModel._meta.get_fields())
+        fields_that_should_be_hidden = incl_hidden - no_hidden
+        for f in incl_hidden:
+            self.assertEqual(f in fields_that_should_be_hidden, f.hidden)
+
+    def test_model_and_reverse_model_should_equal_on_relations(self):
+        for field in AllFieldsModel._meta.get_fields():
+            is_concrete_forward_field = field.concrete and field.related_model
+            if is_concrete_forward_field:
+                reverse_field = field.remote_field
+                self.assertEqual(field.model, reverse_field.related_model)
+                self.assertEqual(field.related_model, reverse_field.model)
+
+    def test_null(self):
+        # null isn't well defined for a ManyToManyField, but changing it to
+        # True causes backwards compatibility problems (#25320).
+        self.assertFalse(AllFieldsModel._meta.get_field("m2m").null)
+        self.assertTrue(AllFieldsModel._meta.get_field("reverse2").null)

testbed/django__django/tests/model_fields/test_filepathfield.py

@@ -0,0 +1,22 @@
+import os
+
+from django.db.models import FilePathField
+from django.test import SimpleTestCase
+
+
+class FilePathFieldTests(SimpleTestCase):
+    def test_path(self):
+        path = os.path.dirname(__file__)
+        field = FilePathField(path=path)
+        self.assertEqual(field.path, path)
+        self.assertEqual(field.formfield().path, path)
+
+    def test_callable_path(self):
+        path = os.path.dirname(__file__)
+
+        def generate_path():
+            return path
+
+        field = FilePathField(path=generate_path)
+        self.assertEqual(field.path(), path)
+        self.assertEqual(field.formfield().path, path)

testbed/django__django/tests/model_fields/test_foreignkey.py

@@ -0,0 +1,169 @@
+from decimal import Decimal
+
+from django.apps import apps
+from django.core import checks
+from django.core.exceptions import FieldError
+from django.db import models
+from django.test import TestCase, skipIfDBFeature
+from django.test.utils import isolate_apps
+
+from .models import Bar, FkToChar, Foo, PrimaryKeyCharModel
+
+
+class ForeignKeyTests(TestCase):
+    def test_callable_default(self):
+        """A lazy callable may be used for ForeignKey.default."""
+        a = Foo.objects.create(id=1, a="abc", d=Decimal("12.34"))
+        b = Bar.objects.create(b="bcd")
+        self.assertEqual(b.a, a)
+
+    @skipIfDBFeature("interprets_empty_strings_as_nulls")
+    def test_empty_string_fk(self):
+        """
+        Empty strings foreign key values don't get converted to None (#19299).
+        """
+        char_model_empty = PrimaryKeyCharModel.objects.create(string="")
+        fk_model_empty = FkToChar.objects.create(out=char_model_empty)
+        fk_model_empty = FkToChar.objects.select_related("out").get(
+            id=fk_model_empty.pk
+        )
+        self.assertEqual(fk_model_empty.out, char_model_empty)
+
+    @isolate_apps("model_fields")
+    def test_warning_when_unique_true_on_fk(self):
+        class Foo(models.Model):
+            pass
+
+        class FKUniqueTrue(models.Model):
+            fk_field = models.ForeignKey(Foo, models.CASCADE, unique=True)
+
+        model = FKUniqueTrue()
+        expected_warnings = [
+            checks.Warning(
+                "Setting unique=True on a ForeignKey has the same effect as using a "
+                "OneToOneField.",
+                hint=(
+                    "ForeignKey(unique=True) is usually better served by a "
+                    "OneToOneField."
+                ),
+                obj=FKUniqueTrue.fk_field.field,
+                id="fields.W342",
+            )
+        ]
+        warnings = model.check()
+        self.assertEqual(warnings, expected_warnings)
+
+    def test_related_name_converted_to_text(self):
+        rel_name = Bar._meta.get_field("a").remote_field.related_name
+        self.assertIsInstance(rel_name, str)
+
+    def test_abstract_model_pending_operations(self):
+        """
+        Foreign key fields declared on abstract models should not add lazy
+        relations to resolve relationship declared as string (#24215).
+        """
+        pending_ops_before = list(apps._pending_operations.items())
+
+        class AbstractForeignKeyModel(models.Model):
+            fk = models.ForeignKey("missing.FK", models.CASCADE)
+
+            class Meta:
+                abstract = True
+
+        self.assertIs(AbstractForeignKeyModel._meta.apps, apps)
+        self.assertEqual(
+            pending_ops_before,
+            list(apps._pending_operations.items()),
+            "Pending lookup added for a foreign key on an abstract model",
+        )
+
+    @isolate_apps("model_fields", "model_fields.tests")
+    def test_abstract_model_app_relative_foreign_key(self):
+        class AbstractReferent(models.Model):
+            reference = models.ForeignKey("Referred", on_delete=models.CASCADE)
+
+            class Meta:
+                app_label = "model_fields"
+                abstract = True
+
+        def assert_app_model_resolved(label):
+            class Referred(models.Model):
+                class Meta:
+                    app_label = label
+
+            class ConcreteReferent(AbstractReferent):
+                class Meta:
+                    app_label = label
+
+            self.assertEqual(
+                ConcreteReferent._meta.get_field("reference").related_model, Referred
+            )
+
+        assert_app_model_resolved("model_fields")
+        assert_app_model_resolved("tests")
+
+    @isolate_apps("model_fields")
+    def test_to_python(self):
+        class Foo(models.Model):
+            pass
+
+        class Bar(models.Model):
+            fk = models.ForeignKey(Foo, models.CASCADE)
+
+        self.assertEqual(Bar._meta.get_field("fk").to_python("1"), 1)
+
+    @isolate_apps("model_fields")
+    def test_fk_to_fk_get_col_output_field(self):
+        class Foo(models.Model):
+            pass
+
+        class Bar(models.Model):
+            foo = models.ForeignKey(Foo, models.CASCADE, primary_key=True)
+
+        class Baz(models.Model):
+            bar = models.ForeignKey(Bar, models.CASCADE, primary_key=True)
+
+        col = Baz._meta.get_field("bar").get_col("alias")
+        self.assertIs(col.output_field, Foo._meta.pk)
+
+    @isolate_apps("model_fields")
+    def test_recursive_fks_get_col(self):
+        class Foo(models.Model):
+            bar = models.ForeignKey("Bar", models.CASCADE, primary_key=True)
+
+        class Bar(models.Model):
+            foo = models.ForeignKey(Foo, models.CASCADE, primary_key=True)
+
+        with self.assertRaisesMessage(ValueError, "Cannot resolve output_field"):
+            Foo._meta.get_field("bar").get_col("alias")
+
+    @isolate_apps("model_fields")
+    def test_non_local_to_field(self):
+        class Parent(models.Model):
+            key = models.IntegerField(unique=True)
+
+        class Child(Parent):
+            pass
+
+        class Related(models.Model):
+            child = models.ForeignKey(Child, on_delete=models.CASCADE, to_field="key")
+
+        msg = (
+            "'model_fields.Related.child' refers to field 'key' which is not "
+            "local to model 'model_fields.Child'."
+        )
+        with self.assertRaisesMessage(FieldError, msg):
+            Related._meta.get_field("child").related_fields
+
+    def test_invalid_to_parameter(self):
+        msg = (
+            "ForeignKey(1) is invalid. First parameter to ForeignKey must be "
+            "either a model, a model name, or the string 'self'"
+        )
+        with self.assertRaisesMessage(TypeError, msg):
+
+            class MyModel(models.Model):
+                child = models.ForeignKey(1, models.CASCADE)
+
+    def test_manager_class_getitem(self):
+        self.assertIs(models.ForeignKey["Foo"], models.ForeignKey)

testbed/django__django/tests/model_fields/test_jsonfield.py

@@ -0,0 +1,1144 @@
+import operator
+import uuid
+from unittest import mock
+
+from django import forms
+from django.core import serializers
+from django.core.exceptions import ValidationError
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db import (
+    DataError,
+    IntegrityError,
+    NotSupportedError,
+    OperationalError,
+    connection,
+    models,
+)
+from django.db.models import (
+    Count,
+    ExpressionWrapper,
+    F,
+    IntegerField,
+    JSONField,
+    OuterRef,
+    Q,
+    Subquery,
+    Transform,
+    Value,
+)
+from django.db.models.expressions import RawSQL
+from django.db.models.fields.json import (
+    KT,
+    KeyTextTransform,
+    KeyTransform,
+    KeyTransformFactory,
+    KeyTransformTextLookupMixin,
+)
+from django.db.models.functions import Cast
+from django.test import SimpleTestCase, TestCase, skipIfDBFeature, skipUnlessDBFeature
+from django.test.utils import CaptureQueriesContext
+from django.utils.deprecation import RemovedInDjango51Warning
+
+from .models import CustomJSONDecoder, JSONModel, NullableJSONModel, RelatedJSONModel
+
+
+@skipUnlessDBFeature("supports_json_field")
+class JSONFieldTests(TestCase):
+    def test_invalid_value(self):
+        msg = "is not JSON serializable"
+        with self.assertRaisesMessage(TypeError, msg):
+            NullableJSONModel.objects.create(
+                value={
+                    "uuid": uuid.UUID("d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475"),
+                }
+            )
+
+    def test_custom_encoder_decoder(self):
+        value = {"uuid": uuid.UUID("{d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475}")}
+        obj = NullableJSONModel(value_custom=value)
+        obj.clean_fields()
+        obj.save()
+        obj.refresh_from_db()
+        self.assertEqual(obj.value_custom, value)
+
+    def test_db_check_constraints(self):
+        value = "{@!invalid json value 123 $!@#"
+        with mock.patch.object(DjangoJSONEncoder, "encode", return_value=value):
+            with self.assertRaises((IntegrityError, DataError, OperationalError)):
+                NullableJSONModel.objects.create(value_custom=value)
+
+
+class TestMethods(SimpleTestCase):
+    def test_deconstruct(self):
+        field = models.JSONField()
+        name, path, args, kwargs = field.deconstruct()
+        self.assertEqual(path, "django.db.models.JSONField")
+        self.assertEqual(args, [])
+        self.assertEqual(kwargs, {})
+
+    def test_deconstruct_custom_encoder_decoder(self):
+        field = models.JSONField(encoder=DjangoJSONEncoder, decoder=CustomJSONDecoder)
+        name, path, args, kwargs = field.deconstruct()
+        self.assertEqual(kwargs["encoder"], DjangoJSONEncoder)
+        self.assertEqual(kwargs["decoder"], CustomJSONDecoder)
+
+    def test_get_transforms(self):
+        @models.JSONField.register_lookup
+        class MyTransform(Transform):
+            lookup_name = "my_transform"
+
+        field = models.JSONField()
+        transform = field.get_transform("my_transform")
+        self.assertIs(transform, MyTransform)
+        models.JSONField._unregister_lookup(MyTransform)
+        transform = field.get_transform("my_transform")
+        self.assertIsInstance(transform, KeyTransformFactory)
+
+    def test_key_transform_text_lookup_mixin_non_key_transform(self):
+        transform = Transform("test")
+        msg = (
+            "Transform should be an instance of KeyTransform in order to use "
+            "this lookup."
+        )
+        with self.assertRaisesMessage(TypeError, msg):
+            KeyTransformTextLookupMixin(transform)
+
+    def test_get_prep_value(self):
+        class JSONFieldGetPrepValue(models.JSONField):
+            def get_prep_value(self, value):
+                if value is True:
+                    return {"value": True}
+                return value
+
+        def noop_adapt_json_value(value, encoder):
+            return value
+
+        field = JSONFieldGetPrepValue()
+        with mock.patch.object(
+            connection.ops, "adapt_json_value", noop_adapt_json_value
+        ):
+            self.assertEqual(
+                field.get_db_prep_value(True, connection, prepared=False),
+                {"value": True},
+            )
+            self.assertIs(
+                field.get_db_prep_value(True, connection, prepared=True), True
+            )
+            self.assertEqual(field.get_db_prep_value(1, connection, prepared=False), 1)
+
+
+class TestValidation(SimpleTestCase):
+    def test_invalid_encoder(self):
+        msg = "The encoder parameter must be a callable object."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.JSONField(encoder=DjangoJSONEncoder())
+
+    def test_invalid_decoder(self):
+        msg = "The decoder parameter must be a callable object."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.JSONField(decoder=CustomJSONDecoder())
+
+    def test_validation_error(self):
+        field = models.JSONField()
+        msg = "Value must be valid JSON."
+        value = uuid.UUID("{d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475}")
+        with self.assertRaisesMessage(ValidationError, msg):
+            field.clean({"uuid": value}, None)
+
+    def test_custom_encoder(self):
+        field = models.JSONField(encoder=DjangoJSONEncoder)
+        value = uuid.UUID("{d85e2076-b67c-4ee7-8c3a-2bf5a2cc2475}")
+        field.clean({"uuid": value}, None)
+
+
+class TestFormField(SimpleTestCase):
+    def test_formfield(self):
+        model_field = models.JSONField()
+        form_field = model_field.formfield()
+        self.assertIsInstance(form_field, forms.JSONField)
+
+    def test_formfield_custom_encoder_decoder(self):
+        model_field = models.JSONField(
+            encoder=DjangoJSONEncoder, decoder=CustomJSONDecoder
+        )
+        form_field = model_field.formfield()
+        self.assertIs(form_field.encoder, DjangoJSONEncoder)
+        self.assertIs(form_field.decoder, CustomJSONDecoder)
+
+
+class TestSerialization(SimpleTestCase):
+    test_data = (
+        '[{"fields": {"value": %s}, "model": "model_fields.jsonmodel", "pk": null}]'
+    )
+    test_values = (
+        # (Python value, serialized value),
+        ({"a": "b", "c": None}, '{"a": "b", "c": null}'),
+        ("abc", '"abc"'),
+        ('{"a": "a"}', '"{\\"a\\": \\"a\\"}"'),
+    )
+
+    def test_dumping(self):
+        for value, serialized in self.test_values:
+            with self.subTest(value=value):
+                instance = JSONModel(value=value)
+                data = serializers.serialize("json", [instance])
+                self.assertJSONEqual(data, self.test_data % serialized)
+
+    def test_loading(self):
+        for value, serialized in self.test_values:
+            with self.subTest(value=value):
+                instance = list(
+                    serializers.deserialize("json", self.test_data % serialized)
+                )[0].object
+                self.assertEqual(instance.value, value)
+
+    def test_xml_serialization(self):
+        test_xml_data = (
+            '<django-objects version="1.0">'
+            '<object model="model_fields.nullablejsonmodel">'
+            '<field name="value" type="JSONField">%s'
+            "</field></object></django-objects>"
+        )
+        for value, serialized in self.test_values:
+            with self.subTest(value=value):
+                instance = NullableJSONModel(value=value)
+                data = serializers.serialize("xml", [instance], fields=["value"])
+                self.assertXMLEqual(data, test_xml_data % serialized)
+                new_instance = list(serializers.deserialize("xml", data))[0].object
+                self.assertEqual(new_instance.value, instance.value)
+
+
+@skipUnlessDBFeature("supports_json_field")
+class TestSaveLoad(TestCase):
+    def test_null(self):
+        obj = NullableJSONModel(value=None)
+        obj.save()
+        obj.refresh_from_db()
+        self.assertIsNone(obj.value)
+
+    def test_ambiguous_str_value_deprecation(self):
+        msg = (
+            "Providing an encoded JSON string via Value() is deprecated. Use Value([], "
+            "output_field=JSONField()) instead."
+        )
+        with self.assertWarnsMessage(RemovedInDjango51Warning, msg):
+            obj = NullableJSONModel.objects.create(value=Value("[]"))
+        obj.refresh_from_db()
+        self.assertEqual(obj.value, [])
+
+    @skipUnlessDBFeature("supports_primitives_in_json_field")
+    def test_value_str_primitives_deprecation(self):
+        msg = (
+            "Providing an encoded JSON string via Value() is deprecated. Use "
+            "Value(None, output_field=JSONField()) instead."
+        )
+        with self.assertWarnsMessage(RemovedInDjango51Warning, msg):
+            obj = NullableJSONModel.objects.create(value=Value("null"))
+        obj.refresh_from_db()
+        self.assertIsNone(obj.value)
+        obj = NullableJSONModel.objects.create(value=Value("invalid-json"))
+        obj.refresh_from_db()
+        self.assertEqual(obj.value, "invalid-json")
+
+    @skipUnlessDBFeature("supports_primitives_in_json_field")
+    def test_json_null_different_from_sql_null(self):
+        json_null = NullableJSONModel.objects.create(value=Value(None, JSONField()))
+        NullableJSONModel.objects.update(value=Value(None, JSONField()))
+        json_null.refresh_from_db()
+        sql_null = NullableJSONModel.objects.create(value=None)
+        sql_null.refresh_from_db()
+        # 'null' is not equal to NULL in the database.
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value=Value(None, JSONField())),
+            [json_null],
+        )
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value=None),
+            [json_null],
+        )
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__isnull=True),
+            [sql_null],
+        )
+        # 'null' is equal to NULL in Python (None).
+        self.assertEqual(json_null.value, sql_null.value)
+
+    @skipUnlessDBFeature("supports_primitives_in_json_field")
+    def test_primitives(self):
+        values = [
+            True,
+            1,
+            1.45,
+            "String",
+            "",
+        ]
+        for value in values:
+            with self.subTest(value=value):
+                obj = JSONModel(value=value)
+                obj.save()
+                obj.refresh_from_db()
+                self.assertEqual(obj.value, value)
+
+    def test_dict(self):
+        values = [
+            {},
+            {"name": "John", "age": 20, "height": 180.3},
+            {"a": True, "b": {"b1": False, "b2": None}},
+        ]
+        for value in values:
+            with self.subTest(value=value):
+                obj = JSONModel.objects.create(value=value)
+                obj.refresh_from_db()
+                self.assertEqual(obj.value, value)
+
+    def test_list(self):
+        values = [
+            [],
+            ["John", 20, 180.3],
+            [True, [False, None]],
+        ]
+        for value in values:
+            with self.subTest(value=value):
+                obj = JSONModel.objects.create(value=value)
+                obj.refresh_from_db()
+                self.assertEqual(obj.value, value)
+
+    def test_realistic_object(self):
+        value = {
+            "name": "John",
+            "age": 20,
+            "pets": [
+                {"name": "Kit", "type": "cat", "age": 2},
+                {"name": "Max", "type": "dog", "age": 1},
+            ],
+            "courses": [
+                ["A1", "A2", "A3"],
+                ["B1", "B2"],
+                ["C1"],
+            ],
+        }
+        obj = JSONModel.objects.create(value=value)
+        obj.refresh_from_db()
+        self.assertEqual(obj.value, value)
+
+
+@skipUnlessDBFeature("supports_json_field")
+class TestQuerying(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.primitives = [True, False, "yes", 7, 9.6]
+        values = [
+            None,
+            [],
+            {},
+            {"a": "b", "c": 14},
+            {
+                "a": "b",
+                "c": 14,
+                "d": ["e", {"f": "g"}],
+                "h": True,
+                "i": False,
+                "j": None,
+                "k": {"l": "m"},
+                "n": [None, True, False],
+                "o": '"quoted"',
+                "p": 4.2,
+                "r": {"s": True, "t": False},
+            },
+            [1, [2]],
+            {"k": True, "l": False, "foo": "bax"},
+            {
+                "foo": "bar",
+                "baz": {"a": "b", "c": "d"},
+                "bar": ["foo", "bar"],
+                "bax": {"foo": "bar"},
+            },
+        ]
+        cls.objs = [NullableJSONModel.objects.create(value=value) for value in values]
+        if connection.features.supports_primitives_in_json_field:
+            cls.objs.extend(
+                [
+                    NullableJSONModel.objects.create(value=value)
+                    for value in cls.primitives
+                ]
+            )
+        cls.raw_sql = "%s::jsonb" if connection.vendor == "postgresql" else "%s"
+
+    def test_exact(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__exact={}),
+            [self.objs[2]],
+        )
+
+    def test_exact_complex(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__exact={"a": "b", "c": 14}),
+            [self.objs[3]],
+        )
+
+    def test_icontains(self):
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__icontains="BaX"),
+            self.objs[6:8],
+        )
+
+    def test_isnull(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__isnull=True),
+            [self.objs[0]],
+        )
+
+    def test_ordering_by_transform(self):
+        mariadb = connection.vendor == "mysql" and connection.mysql_is_mariadb
+        values = [
+            {"ord": 93, "name": "bar"},
+            {"ord": 22.1, "name": "foo"},
+            {"ord": -1, "name": "baz"},
+            {"ord": 21.931902, "name": "spam"},
+            {"ord": -100291029, "name": "eggs"},
+        ]
+        for field_name in ["value", "value_custom"]:
+            with self.subTest(field=field_name):
+                objs = [
+                    NullableJSONModel.objects.create(**{field_name: value})
+                    for value in values
+                ]
+                query = NullableJSONModel.objects.filter(
+                    **{"%s__name__isnull" % field_name: False},
+                ).order_by("%s__ord" % field_name)
+                expected = [objs[4], objs[2], objs[3], objs[1], objs[0]]
+                if mariadb or connection.vendor == "oracle":
+                    # MariaDB and Oracle return JSON values as strings.
+                    expected = [objs[2], objs[4], objs[3], objs[1], objs[0]]
+                self.assertSequenceEqual(query, expected)
+
+    def test_ordering_grouping_by_key_transform(self):
+        base_qs = NullableJSONModel.objects.filter(value__d__0__isnull=False)
+        for qs in (
+            base_qs.order_by("value__d__0"),
+            base_qs.annotate(
+                key=KeyTransform("0", KeyTransform("d", "value"))
+            ).order_by("key"),
+        ):
+            self.assertSequenceEqual(qs, [self.objs[4]])
+        none_val = "" if connection.features.interprets_empty_strings_as_nulls else None
+        qs = NullableJSONModel.objects.filter(value__isnull=False)
+        self.assertQuerySetEqual(
+            qs.filter(value__isnull=False)
+            .annotate(key=KT("value__d__1__f"))
+            .values("key")
+            .annotate(count=Count("key"))
+            .order_by("count"),
+            [(none_val, 0), ("g", 1)],
+            operator.itemgetter("key", "count"),
+        )
+
+    def test_ordering_grouping_by_count(self):
+        qs = (
+            NullableJSONModel.objects.filter(
+                value__isnull=False,
+            )
+            .values("value__d__0")
+            .annotate(count=Count("value__d__0"))
+            .order_by("count")
+        )
+        self.assertQuerySetEqual(qs, [0, 1], operator.itemgetter("count"))
+
+    def test_order_grouping_custom_decoder(self):
+        NullableJSONModel.objects.create(value_custom={"a": "b"})
+        qs = NullableJSONModel.objects.filter(value_custom__isnull=False)
+        self.assertSequenceEqual(
+            qs.values(
+                "value_custom__a",
+            )
+            .annotate(
+                count=Count("id"),
+            )
+            .order_by("value_custom__a"),
+            [{"value_custom__a": "b", "count": 1}],
+        )
+
+    def test_key_transform_raw_expression(self):
+        expr = RawSQL(self.raw_sql, ['{"x": "bar"}'])
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__foo=KeyTransform("x", expr)),
+            [self.objs[7]],
+        )
+
+    def test_nested_key_transform_raw_expression(self):
+        expr = RawSQL(self.raw_sql, ['{"x": {"y": "bar"}}'])
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(
+                value__foo=KeyTransform("y", KeyTransform("x", expr))
+            ),
+            [self.objs[7]],
+        )
+
+    def test_key_transform_expression(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__d__0__isnull=False)
+            .annotate(
+                key=KeyTransform("d", "value"),
+                chain=KeyTransform("0", "key"),
+                expr=KeyTransform("0", Cast("key", models.JSONField())),
+            )
+            .filter(chain=F("expr")),
+            [self.objs[4]],
+        )
+
+    def test_key_transform_annotation_expression(self):
+        obj = NullableJSONModel.objects.create(value={"d": ["e", "e"]})
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__d__0__isnull=False)
+            .annotate(
+                key=F("value__d"),
+                chain=F("key__0"),
+                expr=Cast("key", models.JSONField()),
+            )
+            .filter(chain=F("expr__1")),
+            [obj],
+        )
+
+    def test_nested_key_transform_expression(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__d__0__isnull=False)
+            .annotate(
+                key=KeyTransform("d", "value"),
+                chain=KeyTransform("f", KeyTransform("1", "key")),
+                expr=KeyTransform(
+                    "f", KeyTransform("1", Cast("key", models.JSONField()))
+                ),
+            )
+            .filter(chain=F("expr")),
+            [self.objs[4]],
+        )
+
+    def test_nested_key_transform_annotation_expression(self):
+        obj = NullableJSONModel.objects.create(
+            value={"d": ["e", {"f": "g"}, {"f": "g"}]},
+        )
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__d__0__isnull=False)
+            .annotate(
+                key=F("value__d"),
+                chain=F("key__1__f"),
+                expr=Cast("key", models.JSONField()),
+            )
+            .filter(chain=F("expr__2__f")),
+            [obj],
+        )
+
+    def test_nested_key_transform_on_subquery(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__d__0__isnull=False)
+            .annotate(
+                subquery_value=Subquery(
+                    NullableJSONModel.objects.filter(pk=OuterRef("pk")).values("value")
+                ),
+                key=KeyTransform("d", "subquery_value"),
+                chain=KeyTransform("f", KeyTransform("1", "key")),
+            )
+            .filter(chain="g"),
+            [self.objs[4]],
+        )
+
+    def test_key_text_transform_char_lookup(self):
+        qs = NullableJSONModel.objects.annotate(
+            char_value=KeyTextTransform("foo", "value"),
+        ).filter(char_value__startswith="bar")
+        self.assertSequenceEqual(qs, [self.objs[7]])
+
+        qs = NullableJSONModel.objects.annotate(
+            char_value=KeyTextTransform(1, KeyTextTransform("bar", "value")),
+        ).filter(char_value__startswith="bar")
+        self.assertSequenceEqual(qs, [self.objs[7]])
+
+    def test_expression_wrapper_key_transform(self):
+        self.assertCountEqual(
+            NullableJSONModel.objects.annotate(
+                expr=ExpressionWrapper(
+                    KeyTransform("c", "value"),
+                    output_field=IntegerField(),
+                ),
+            ).filter(expr__isnull=False),
+            self.objs[3:5],
+        )
+
+    def test_has_key(self):
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__has_key="a"),
+            [self.objs[3], self.objs[4]],
+        )
+
+    def test_has_key_null_value(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__has_key="j"),
+            [self.objs[4]],
+        )
+
+    def test_has_key_deep(self):
+        tests = [
+            (Q(value__baz__has_key="a"), self.objs[7]),
+            (
+                Q(value__has_key=KeyTransform("a", KeyTransform("baz", "value"))),
+                self.objs[7],
+            ),
+            (Q(value__has_key=F("value__baz__a")), self.objs[7]),
+            (
+                Q(value__has_key=KeyTransform("c", KeyTransform("baz", "value"))),
+                self.objs[7],
+            ),
+            (Q(value__has_key=F("value__baz__c")), self.objs[7]),
+            (Q(value__d__1__has_key="f"), self.objs[4]),
+            (
+                Q(
+                    value__has_key=KeyTransform(
+                        "f", KeyTransform("1", KeyTransform("d", "value"))
+                    )
+                ),
+                self.objs[4],
+            ),
+            (Q(value__has_key=F("value__d__1__f")), self.objs[4]),
+        ]
+        for condition, expected in tests:
+            with self.subTest(condition=condition):
+                self.assertSequenceEqual(
+                    NullableJSONModel.objects.filter(condition),
+                    [expected],
+                )
+
+    def test_has_key_list(self):
+        obj = NullableJSONModel.objects.create(value=[{"a": 1}, {"b": "x"}])
+        tests = [
+            Q(value__1__has_key="b"),
+            Q(value__has_key=KeyTransform("b", KeyTransform(1, "value"))),
+            Q(value__has_key=KeyTransform("b", KeyTransform("1", "value"))),
+            Q(value__has_key=F("value__1__b")),
+        ]
+        for condition in tests:
+            with self.subTest(condition=condition):
+                self.assertSequenceEqual(
+                    NullableJSONModel.objects.filter(condition),
+                    [obj],
+                )
+
+    def test_has_keys(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__has_keys=["a", "c", "h"]),
+            [self.objs[4]],
+        )
+
+    def test_has_any_keys(self):
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__has_any_keys=["c", "l"]),
+            [self.objs[3], self.objs[4], self.objs[6]],
+        )
+
+    def test_has_key_number(self):
+        obj = NullableJSONModel.objects.create(
+            value={
+                "123": "value",
+                "nested": {"456": "bar", "lorem": "abc", "999": True},
+                "array": [{"789": "baz", "777": "def", "ipsum": 200}],
+                "000": "val",
+            }
+        )
+        tests = [
+            Q(value__has_key="123"),
+            Q(value__nested__has_key="456"),
+            Q(value__array__0__has_key="789"),
+            Q(value__has_keys=["nested", "123", "array", "000"]),
+            Q(value__nested__has_keys=["lorem", "999", "456"]),
+            Q(value__array__0__has_keys=["789", "ipsum", "777"]),
+            Q(value__has_any_keys=["000", "nonexistent"]),
+            Q(value__nested__has_any_keys=["999", "nonexistent"]),
+            Q(value__array__0__has_any_keys=["777", "nonexistent"]),
+        ]
+        for condition in tests:
+            with self.subTest(condition=condition):
+                self.assertSequenceEqual(
+                    NullableJSONModel.objects.filter(condition),
+                    [obj],
+                )
+
+    @skipUnlessDBFeature("supports_json_field_contains")
+    def test_contains(self):
+        tests = [
+            ({}, self.objs[2:5] + self.objs[6:8]),
+            ({"baz": {"a": "b", "c": "d"}}, [self.objs[7]]),
+            ({"baz": {"a": "b"}}, [self.objs[7]]),
+            ({"baz": {"c": "d"}}, [self.objs[7]]),
+            ({"k": True, "l": False}, [self.objs[6]]),
+            ({"d": ["e", {"f": "g"}]}, [self.objs[4]]),
+            ({"d": ["e"]}, [self.objs[4]]),
+            ({"d": [{"f": "g"}]}, [self.objs[4]]),
+            ([1, [2]], [self.objs[5]]),
+            ([1], [self.objs[5]]),
+            ([[2]], [self.objs[5]]),
+            ({"n": [None, True, False]}, [self.objs[4]]),
+            ({"j": None}, [self.objs[4]]),
+        ]
+        for value, expected in tests:
+            with self.subTest(value=value):
+                qs = NullableJSONModel.objects.filter(value__contains=value)
+                self.assertCountEqual(qs, expected)
+
+    @skipIfDBFeature("supports_json_field_contains")
+    def test_contains_unsupported(self):
+        msg = "contains lookup is not supported on this database backend."
+        with self.assertRaisesMessage(NotSupportedError, msg):
+            NullableJSONModel.objects.filter(
+                value__contains={"baz": {"a": "b", "c": "d"}},
+            ).get()
+
+    @skipUnlessDBFeature(
+        "supports_primitives_in_json_field",
+        "supports_json_field_contains",
+    )
+    def test_contains_primitives(self):
+        for value in self.primitives:
+            with self.subTest(value=value):
+                qs = NullableJSONModel.objects.filter(value__contains=value)
+                self.assertIs(qs.exists(), True)
+
+    @skipUnlessDBFeature("supports_json_field_contains")
+    def test_contained_by(self):
+        qs = NullableJSONModel.objects.filter(
+            value__contained_by={"a": "b", "c": 14, "h": True}
+        )
+        self.assertCountEqual(qs, self.objs[2:4])
+
+    @skipIfDBFeature("supports_json_field_contains")
+    def test_contained_by_unsupported(self):
+        msg = "contained_by lookup is not supported on this database backend."
+        with self.assertRaisesMessage(NotSupportedError, msg):
+            NullableJSONModel.objects.filter(value__contained_by={"a": "b"}).get()
+
+    def test_deep_values(self):
+        qs = NullableJSONModel.objects.values_list("value__k__l").order_by("pk")
+        expected_objs = [(None,)] * len(self.objs)
+        expected_objs[4] = ("m",)
+        self.assertSequenceEqual(qs, expected_objs)
+
+    @skipUnlessDBFeature("can_distinct_on_fields")
+    def test_deep_distinct(self):
+        query = NullableJSONModel.objects.distinct("value__k__l").values_list(
+            "value__k__l"
+        )
+        self.assertSequenceEqual(query, [("m",), (None,)])
+
+    def test_isnull_key(self):
+        # key__isnull=False works the same as has_key='key'.
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__a__isnull=True),
+            self.objs[:3] + self.objs[5:],
+        )
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__j__isnull=True),
+            self.objs[:4] + self.objs[5:],
+        )
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__a__isnull=False),
+            [self.objs[3], self.objs[4]],
+        )
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__j__isnull=False),
+            [self.objs[4]],
+        )
+
+    def test_isnull_key_or_none(self):
+        obj = NullableJSONModel.objects.create(value={"a": None})
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(
+                Q(value__a__isnull=True) | Q(value__a=None)
+            ),
+            self.objs[:3] + self.objs[5:] + [obj],
+        )
+
+    def test_none_key(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__j=None),
+            [self.objs[4]],
+        )
+
+    def test_none_key_exclude(self):
+        obj = NullableJSONModel.objects.create(value={"j": 1})
+        if connection.vendor == "oracle":
+            # Oracle supports filtering JSON objects with NULL keys, but the
+            # current implementation doesn't support it.
+            self.assertSequenceEqual(
+                NullableJSONModel.objects.exclude(value__j=None),
+                self.objs[1:4] + self.objs[5:] + [obj],
+            )
+        else:
+            self.assertSequenceEqual(
+                NullableJSONModel.objects.exclude(value__j=None), [obj]
+            )
+
+    def test_shallow_list_lookup(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__0=1),
+            [self.objs[5]],
+        )
+
+    def test_shallow_obj_lookup(self):
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__a="b"),
+            [self.objs[3], self.objs[4]],
+        )
+
+    def test_obj_subquery_lookup(self):
+        qs = NullableJSONModel.objects.annotate(
+            field=Subquery(
+                NullableJSONModel.objects.filter(pk=OuterRef("pk")).values("value")
+            ),
+        ).filter(field__a="b")
+        self.assertCountEqual(qs, [self.objs[3], self.objs[4]])
+
+    def test_deep_lookup_objs(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__k__l="m"),
+            [self.objs[4]],
+        )
+
+    def test_shallow_lookup_obj_target(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__k={"l": "m"}),
+            [self.objs[4]],
+        )
+
+    def test_deep_lookup_array(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__1__0=2),
+            [self.objs[5]],
+        )
+
+    def test_deep_lookup_mixed(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__d__1__f="g"),
+            [self.objs[4]],
+        )
+
+    def test_deep_lookup_transform(self):
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__c__gt=2),
+            [self.objs[3], self.objs[4]],
+        )
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(value__c__gt=2.33),
+            [self.objs[3], self.objs[4]],
+        )
+        self.assertIs(NullableJSONModel.objects.filter(value__c__lt=5).exists(), False)
+
+    def test_lookup_exclude(self):
+        tests = [
+            (Q(value__a="b"), [self.objs[0]]),
+            (Q(value__foo="bax"), [self.objs[0], self.objs[7]]),
+        ]
+        for condition, expected in tests:
+            self.assertCountEqual(
+                NullableJSONModel.objects.exclude(condition),
+                expected,
+            )
+            self.assertCountEqual(
+                NullableJSONModel.objects.filter(~condition),
+                expected,
+            )
+
+    def test_lookup_exclude_nonexistent_key(self):
+        # Values without the key are ignored.
+        condition = Q(value__foo="bax")
+        objs_with_value = [self.objs[6]]
+        objs_with_different_value = [self.objs[0], self.objs[7]]
+        self.assertCountEqual(
+            NullableJSONModel.objects.exclude(condition),
+            objs_with_different_value,
+        )
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.exclude(~condition),
+            objs_with_value,
+        )
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(condition | ~condition),
+            objs_with_value + objs_with_different_value,
+        )
+        self.assertCountEqual(
+            NullableJSONModel.objects.exclude(condition & ~condition),
+            objs_with_value + objs_with_different_value,
+        )
+        # Add the __isnull lookup to get an exhaustive set.
+        self.assertCountEqual(
+            NullableJSONModel.objects.exclude(condition & Q(value__foo__isnull=False)),
+            self.objs[0:6] + self.objs[7:],
+        )
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(condition & Q(value__foo__isnull=False)),
+            objs_with_value,
+        )
+
+    def test_usage_in_subquery(self):
+        self.assertCountEqual(
+            NullableJSONModel.objects.filter(
+                id__in=NullableJSONModel.objects.filter(value__c=14),
+            ),
+            self.objs[3:5],
+        )
+
+    @skipUnlessDBFeature("supports_json_field_contains")
+    def test_array_key_contains(self):
+        tests = [
+            ([], [self.objs[7]]),
+            ("bar", [self.objs[7]]),
+            (["bar"], [self.objs[7]]),
+            ("ar", []),
+        ]
+        for value, expected in tests:
+            with self.subTest(value=value):
+                self.assertSequenceEqual(
+                    NullableJSONModel.objects.filter(value__bar__contains=value),
+                    expected,
+                )
+
+    def test_key_iexact(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__iexact="BaR").exists(), True
+        )
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__iexact='"BaR"').exists(), False
+        )
+
+    def test_key_in(self):
+        tests = [
+            ("value__c__in", [14], self.objs[3:5]),
+            ("value__c__in", [14, 15], self.objs[3:5]),
+            ("value__0__in", [1], [self.objs[5]]),
+            ("value__0__in", [1, 3], [self.objs[5]]),
+            ("value__foo__in", ["bar"], [self.objs[7]]),
+            (
+                "value__foo__in",
+                [KeyTransform("foo", KeyTransform("bax", "value"))],
+                [self.objs[7]],
+            ),
+            ("value__foo__in", [F("value__bax__foo")], [self.objs[7]]),
+            (
+                "value__foo__in",
+                [KeyTransform("foo", KeyTransform("bax", "value")), "baz"],
+                [self.objs[7]],
+            ),
+            ("value__foo__in", [F("value__bax__foo"), "baz"], [self.objs[7]]),
+            ("value__foo__in", ["bar", "baz"], [self.objs[7]]),
+            ("value__bar__in", [["foo", "bar"]], [self.objs[7]]),
+            ("value__bar__in", [["foo", "bar"], ["a"]], [self.objs[7]]),
+            ("value__bax__in", [{"foo": "bar"}, {"a": "b"}], [self.objs[7]]),
+            ("value__h__in", [True, "foo"], [self.objs[4]]),
+            ("value__i__in", [False, "foo"], [self.objs[4]]),
+        ]
+        for lookup, value, expected in tests:
+            with self.subTest(lookup=lookup, value=value):
+                self.assertCountEqual(
+                    NullableJSONModel.objects.filter(**{lookup: value}),
+                    expected,
+                )
+
+    def test_key_values(self):
+        qs = NullableJSONModel.objects.filter(value__h=True)
+        tests = [
+            ("value__a", "b"),
+            ("value__c", 14),
+            ("value__d", ["e", {"f": "g"}]),
+            ("value__h", True),
+            ("value__i", False),
+            ("value__j", None),
+            ("value__k", {"l": "m"}),
+            ("value__n", [None, True, False]),
+            ("value__p", 4.2),
+            ("value__r", {"s": True, "t": False}),
+        ]
+        for lookup, expected in tests:
+            with self.subTest(lookup=lookup):
+                self.assertEqual(qs.values_list(lookup, flat=True).get(), expected)
+
+    def test_key_values_boolean(self):
+        qs = NullableJSONModel.objects.filter(value__h=True, value__i=False)
+        tests = [
+            ("value__h", True),
+            ("value__i", False),
+        ]
+        for lookup, expected in tests:
+            with self.subTest(lookup=lookup):
+                self.assertIs(qs.values_list(lookup, flat=True).get(), expected)
+
+    @skipUnlessDBFeature("supports_json_field_contains")
+    def test_key_contains(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__contains="ar").exists(), False
+        )
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__contains="bar").exists(), True
+        )
+
+    def test_key_icontains(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__icontains="Ar").exists(), True
+        )
+
+    def test_key_startswith(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__startswith="b").exists(), True
+        )
+
+    def test_key_istartswith(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__istartswith="B").exists(), True
+        )
+
+    def test_key_endswith(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__endswith="r").exists(), True
+        )
+
+    def test_key_iendswith(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__iendswith="R").exists(), True
+        )
+
+    def test_key_regex(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__regex=r"^bar$").exists(), True
+        )
+
+    def test_key_iregex(self):
+        self.assertIs(
+            NullableJSONModel.objects.filter(value__foo__iregex=r"^bAr$").exists(), True
+        )
+
+    def test_key_quoted_string(self):
+        self.assertEqual(
+            NullableJSONModel.objects.filter(value__o='"quoted"').get(),
+            self.objs[4],
+        )
+
+    @skipUnlessDBFeature("has_json_operators")
+    def test_key_sql_injection(self):
+        with CaptureQueriesContext(connection) as queries:
+            self.assertIs(
+                NullableJSONModel.objects.filter(
+                    **{
+                        """value__test' = '"a"') OR 1 = 1 OR ('d""": "x",
+                    }
+                ).exists(),
+                False,
+            )
+        self.assertIn(
+            """."value" -> 'test'' = ''"a"'') OR 1 = 1 OR (''d') = '"x"'""",
+            queries[0]["sql"],
+        )
+
+    @skipIfDBFeature("has_json_operators")
+    def test_key_sql_injection_escape(self):
+        query = str(
+            JSONModel.objects.filter(
+                **{
+                    """value__test") = '"a"' OR 1 = 1 OR ("d""": "x",
+                }
+            ).query
+        )
+        self.assertIn('"test\\"', query)
+        self.assertIn('\\"d', query)
+
+    def test_key_escape(self):
+        obj = NullableJSONModel.objects.create(value={"%total": 10})
+        self.assertEqual(
+            NullableJSONModel.objects.filter(**{"value__%total": 10}).get(), obj
+        )
+
+    def test_none_key_and_exact_lookup(self):
+        self.assertSequenceEqual(
+            NullableJSONModel.objects.filter(value__a="b", value__j=None),
+            [self.objs[4]],
+        )
+
+    def test_lookups_with_key_transform(self):
+        tests = (
+            ("value__baz__has_key", "c"),
+            ("value__baz__has_keys", ["a", "c"]),
+            ("value__baz__has_any_keys", ["a", "x"]),
+            ("value__has_key", KeyTextTransform("foo", "value")),
+        )
+        for lookup, value in tests:
+            with self.subTest(lookup=lookup):
+                self.assertIs(
+                    NullableJSONModel.objects.filter(
+                        **{lookup: value},
+                    ).exists(),
+                    True,
+                )
+
+    @skipUnlessDBFeature("supports_json_field_contains")
+    def test_contains_contained_by_with_key_transform(self):
+        tests = [
+            ("value__d__contains", "e"),
+            ("value__d__contains", [{"f": "g"}]),
+            ("value__contains", KeyTransform("bax", "value")),
+            ("value__contains", F("value__bax")),
+            ("value__baz__contains", {"a": "b"}),
+            ("value__baz__contained_by", {"a": "b", "c": "d", "e": "f"}),
+            (
+                "value__contained_by",
+                KeyTransform(
+                    "x",
+                    RawSQL(
+                        self.raw_sql,
+                        ['{"x": {"a": "b", "c": 1, "d": "e"}}'],
+                    ),
+                ),
+            ),
+        ]
+        # For databases where {'f': 'g'} (without surrounding []) matches
+        # [{'f': 'g'}].
+        if not connection.features.json_key_contains_list_matching_requires_list:
+            tests.append(("value__d__contains", {"f": "g"}))
+        for lookup, value in tests:
+            with self.subTest(lookup=lookup, value=value):
+                self.assertIs(
+                    NullableJSONModel.objects.filter(
+                        **{lookup: value},
+                    ).exists(),
+                    True,
+                )
+
+    def test_join_key_transform_annotation_expression(self):
+        related_obj = RelatedJSONModel.objects.create(
+            value={"d": ["f", "e"]},
+            json_model=self.objs[4],
+        )
+        RelatedJSONModel.objects.create(
+            value={"d": ["e", "f"]},
+            json_model=self.objs[4],
+        )
+        self.assertSequenceEqual(
+            RelatedJSONModel.objects.annotate(
+                key=F("value__d"),
+                related_key=F("json_model__value__d"),
+                chain=F("key__1"),
+                expr=Cast("key", models.JSONField()),
+            ).filter(chain=F("related_key__0")),
+            [related_obj],
+        )
+
+    def test_key_text_transform_from_lookup(self):
+        qs = NullableJSONModel.objects.annotate(b=KT("value__bax__foo")).filter(
+            b__contains="ar",
+        )
+        self.assertSequenceEqual(qs, [self.objs[7]])
+        qs = NullableJSONModel.objects.annotate(c=KT("value__o")).filter(
+            c__contains="uot",
+        )
+        self.assertSequenceEqual(qs, [self.objs[4]])
+
+    def test_key_text_transform_from_lookup_invalid(self):
+        msg = "Lookup must contain key or index transforms."
+        with self.assertRaisesMessage(ValueError, msg):
+            KT("value")
+        with self.assertRaisesMessage(ValueError, msg):
+            KT("")

testbed/django__django/tests/model_fields/tests.py

@@ -0,0 +1,376 @@
+import pickle
+
+from django import forms
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.test import SimpleTestCase, TestCase
+from django.utils.functional import lazy
+
+from .models import (
+    Bar,
+    Choiceful,
+    Foo,
+    RenamedField,
+    VerboseNameField,
+    Whiz,
+    WhizDelayed,
+    WhizIter,
+    WhizIterEmpty,
+)
+
+
+class Nested:
+    class Field(models.Field):
+        pass
+
+
+class BasicFieldTests(SimpleTestCase):
+    def test_show_hidden_initial(self):
+        """
+        Fields with choices respect show_hidden_initial as a kwarg to
+        formfield().
+        """
+        choices = [(0, 0), (1, 1)]
+        model_field = models.Field(choices=choices)
+        form_field = model_field.formfield(show_hidden_initial=True)
+        self.assertTrue(form_field.show_hidden_initial)
+
+        form_field = model_field.formfield(show_hidden_initial=False)
+        self.assertFalse(form_field.show_hidden_initial)
+
+    def test_field_repr(self):
+        """
+        __repr__() of a field displays its name.
+        """
+        f = Foo._meta.get_field("a")
+        self.assertEqual(repr(f), "<django.db.models.fields.CharField: a>")
+        f = models.fields.CharField()
+        self.assertEqual(repr(f), "<django.db.models.fields.CharField>")
+
+    def test_field_repr_nested(self):
+        """__repr__() uses __qualname__ for nested class support."""
+        self.assertEqual(repr(Nested.Field()), "<model_fields.tests.Nested.Field>")
+
+    def test_field_name(self):
+        """
+        A defined field name (name="fieldname") is used instead of the model
+        model's attribute name (modelname).
+        """
+        instance = RenamedField()
+        self.assertTrue(hasattr(instance, "get_fieldname_display"))
+        self.assertFalse(hasattr(instance, "get_modelname_display"))
+
+    def test_field_verbose_name(self):
+        m = VerboseNameField
+        for i in range(1, 22):
+            self.assertEqual(
+                m._meta.get_field("field%d" % i).verbose_name, "verbose field%d" % i
+            )
+
+        self.assertEqual(m._meta.get_field("id").verbose_name, "verbose pk")
+
+    def test_choices_form_class(self):
+        """Can supply a custom choices form class to Field.formfield()"""
+        choices = [("a", "a")]
+        field = models.CharField(choices=choices)
+        klass = forms.TypedMultipleChoiceField
+        self.assertIsInstance(field.formfield(choices_form_class=klass), klass)
+
+    def test_formfield_disabled(self):
+        """Field.formfield() sets disabled for fields with choices."""
+        field = models.CharField(choices=[("a", "b")])
+        form_field = field.formfield(disabled=True)
+        self.assertIs(form_field.disabled, True)
+
+    def test_field_str(self):
+        f = models.Field()
+        self.assertEqual(str(f), "<django.db.models.fields.Field>")
+        f = Foo._meta.get_field("a")
+        self.assertEqual(str(f), "model_fields.Foo.a")
+
+    def test_field_ordering(self):
+        """Fields are ordered based on their creation."""
+        f1 = models.Field()
+        f2 = models.Field(auto_created=True)
+        f3 = models.Field()
+        self.assertLess(f2, f1)
+        self.assertGreater(f3, f1)
+        self.assertIsNotNone(f1)
+        self.assertNotIn(f2, (None, 1, ""))
+
+    def test_field_instance_is_picklable(self):
+        """Field instances can be pickled."""
+        field = models.Field(max_length=100, default="a string")
+        # Must be picklable with this cached property populated (#28188).
+        field._get_default
+        pickle.dumps(field)
+
+    def test_deconstruct_nested_field(self):
+        """deconstruct() uses __qualname__ for nested class support."""
+        name, path, args, kwargs = Nested.Field().deconstruct()
+        self.assertEqual(path, "model_fields.tests.Nested.Field")
+
+    def test_abstract_inherited_fields(self):
+        """Field instances from abstract models are not equal."""
+
+        class AbstractModel(models.Model):
+            field = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        class InheritAbstractModel1(AbstractModel):
+            pass
+
+        class InheritAbstractModel2(AbstractModel):
+            pass
+
+        abstract_model_field = AbstractModel._meta.get_field("field")
+        inherit1_model_field = InheritAbstractModel1._meta.get_field("field")
+        inherit2_model_field = InheritAbstractModel2._meta.get_field("field")
+
+        self.assertNotEqual(abstract_model_field, inherit1_model_field)
+        self.assertNotEqual(abstract_model_field, inherit2_model_field)
+        self.assertNotEqual(inherit1_model_field, inherit2_model_field)
+
+        self.assertLess(abstract_model_field, inherit1_model_field)
+        self.assertLess(abstract_model_field, inherit2_model_field)
+        self.assertLess(inherit1_model_field, inherit2_model_field)
+
+    def test_hash_immutability(self):
+        field = models.IntegerField()
+        field_hash = hash(field)
+
+        class MyModel(models.Model):
+            rank = field
+
+        self.assertEqual(field_hash, hash(field))
+
+
+class ChoicesTests(SimpleTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.no_choices = Choiceful._meta.get_field("no_choices")
+        cls.empty_choices = Choiceful._meta.get_field("empty_choices")
+        cls.empty_choices_bool = Choiceful._meta.get_field("empty_choices_bool")
+        cls.empty_choices_text = Choiceful._meta.get_field("empty_choices_text")
+        cls.with_choices = Choiceful._meta.get_field("with_choices")
+        cls.choices_from_enum = Choiceful._meta.get_field("choices_from_enum")
+
+    def test_choices(self):
+        self.assertIsNone(self.no_choices.choices)
+        self.assertEqual(self.empty_choices.choices, ())
+        self.assertEqual(self.with_choices.choices, [(1, "A")])
+
+    def test_flatchoices(self):
+        self.assertEqual(self.no_choices.flatchoices, [])
+        self.assertEqual(self.empty_choices.flatchoices, [])
+        self.assertEqual(self.with_choices.flatchoices, [(1, "A")])
+
+    def test_check(self):
+        self.assertEqual(Choiceful.check(), [])
+
+    def test_invalid_choice(self):
+        model_instance = None  # Actual model instance not needed.
+        self.no_choices.validate(0, model_instance)
+        msg = "['Value 99 is not a valid choice.']"
+        with self.assertRaisesMessage(ValidationError, msg):
+            self.empty_choices.validate(99, model_instance)
+        with self.assertRaisesMessage(ValidationError, msg):
+            self.with_choices.validate(99, model_instance)
+
+    def test_formfield(self):
+        no_choices_formfield = self.no_choices.formfield()
+        self.assertIsInstance(no_choices_formfield, forms.IntegerField)
+        fields = (
+            self.empty_choices,
+            self.with_choices,
+            self.empty_choices_bool,
+            self.empty_choices_text,
+        )
+        for field in fields:
+            with self.subTest(field=field):
+                self.assertIsInstance(field.formfield(), forms.ChoiceField)
+
+    def test_choices_from_enum(self):
+        # Choices class was transparently resolved when given as argument.
+        self.assertEqual(self.choices_from_enum.choices, Choiceful.Suit.choices)
+
+
+class GetFieldDisplayTests(SimpleTestCase):
+    def test_choices_and_field_display(self):
+        """
+        get_choices() interacts with get_FIELD_display() to return the expected
+        values.
+        """
+        self.assertEqual(Whiz(c=1).get_c_display(), "First")  # A nested value
+        self.assertEqual(Whiz(c=0).get_c_display(), "Other")  # A top level value
+        self.assertEqual(Whiz(c=9).get_c_display(), 9)  # Invalid value
+        self.assertIsNone(Whiz(c=None).get_c_display())  # Blank value
+        self.assertEqual(Whiz(c="").get_c_display(), "")  # Empty value
+        self.assertEqual(WhizDelayed(c=0).get_c_display(), "Other")  # Delayed choices
+
+    def test_get_FIELD_display_translated(self):
+        """A translated display value is coerced to str."""
+        val = Whiz(c=5).get_c_display()
+        self.assertIsInstance(val, str)
+        self.assertEqual(val, "translated")
+
+    def test_overriding_FIELD_display(self):
+        class FooBar(models.Model):
+            foo_bar = models.IntegerField(choices=[(1, "foo"), (2, "bar")])
+
+            def get_foo_bar_display(self):
+                return "something"
+
+        f = FooBar(foo_bar=1)
+        self.assertEqual(f.get_foo_bar_display(), "something")
+
+    def test_overriding_inherited_FIELD_display(self):
+        class Base(models.Model):
+            foo = models.CharField(max_length=254, choices=[("A", "Base A")])
+
+            class Meta:
+                abstract = True
+
+        class Child(Base):
+            foo = models.CharField(
+                max_length=254, choices=[("A", "Child A"), ("B", "Child B")]
+            )
+
+        self.assertEqual(Child(foo="A").get_foo_display(), "Child A")
+        self.assertEqual(Child(foo="B").get_foo_display(), "Child B")
+
+    def test_iterator_choices(self):
+        """
+        get_choices() works with Iterators.
+        """
+        self.assertEqual(WhizIter(c=1).c, 1)  # A nested value
+        self.assertEqual(WhizIter(c=9).c, 9)  # Invalid value
+        self.assertIsNone(WhizIter(c=None).c)  # Blank value
+        self.assertEqual(WhizIter(c="").c, "")  # Empty value
+
+    def test_empty_iterator_choices(self):
+        """
+        get_choices() works with empty iterators.
+        """
+        self.assertEqual(WhizIterEmpty(c="a").c, "a")  # A nested value
+        self.assertEqual(WhizIterEmpty(c="b").c, "b")  # Invalid value
+        self.assertIsNone(WhizIterEmpty(c=None).c)  # Blank value
+        self.assertEqual(WhizIterEmpty(c="").c, "")  # Empty value
+
+
+class GetChoicesTests(SimpleTestCase):
+    def test_empty_choices(self):
+        choices = []
+        f = models.CharField(choices=choices)
+        self.assertEqual(f.get_choices(include_blank=False), choices)
+
+    def test_blank_in_choices(self):
+        choices = [("", "<><>"), ("a", "A")]
+        f = models.CharField(choices=choices)
+        self.assertEqual(f.get_choices(include_blank=True), choices)
+
+    def test_blank_in_grouped_choices(self):
+        choices = [
+            ("f", "Foo"),
+            ("b", "Bar"),
+            (
+                "Group",
+                (
+                    ("", "No Preference"),
+                    ("fg", "Foo"),
+                    ("bg", "Bar"),
+                ),
+            ),
+        ]
+        f = models.CharField(choices=choices)
+        self.assertEqual(f.get_choices(include_blank=True), choices)
+
+    def test_lazy_strings_not_evaluated(self):
+        lazy_func = lazy(lambda x: 0 / 0, int)  # raises ZeroDivisionError if evaluated.
+        f = models.CharField(choices=[(lazy_func("group"), (("a", "A"), ("b", "B")))])
+        self.assertEqual(f.get_choices(include_blank=True)[0], ("", "---------"))
+
+
+class GetChoicesOrderingTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.foo1 = Foo.objects.create(a="a", d="12.35")
+        cls.foo2 = Foo.objects.create(a="b", d="12.34")
+        cls.bar1 = Bar.objects.create(a=cls.foo1, b="b")
+        cls.bar2 = Bar.objects.create(a=cls.foo2, b="a")
+        cls.field = Bar._meta.get_field("a")
+
+    def assertChoicesEqual(self, choices, objs):
+        self.assertEqual(choices, [(obj.pk, str(obj)) for obj in objs])
+
+    def test_get_choices(self):
+        self.assertChoicesEqual(
+            self.field.get_choices(include_blank=False, ordering=("a",)),
+            [self.foo1, self.foo2],
+        )
+        self.assertChoicesEqual(
+            self.field.get_choices(include_blank=False, ordering=("-a",)),
+            [self.foo2, self.foo1],
+        )
+
+    def test_get_choices_default_ordering(self):
+        self.addCleanup(setattr, Foo._meta, "ordering", Foo._meta.ordering)
+        Foo._meta.ordering = ("d",)
+        self.assertChoicesEqual(
+            self.field.get_choices(include_blank=False), [self.foo2, self.foo1]
+        )
+
+    def test_get_choices_reverse_related_field(self):
+        self.assertChoicesEqual(
+            self.field.remote_field.get_choices(include_blank=False, ordering=("a",)),
+            [self.bar1, self.bar2],
+        )
+        self.assertChoicesEqual(
+            self.field.remote_field.get_choices(include_blank=False, ordering=("-a",)),
+            [self.bar2, self.bar1],
+        )
+
+    def test_get_choices_reverse_related_field_default_ordering(self):
+        self.addCleanup(setattr, Bar._meta, "ordering", Bar._meta.ordering)
+        Bar._meta.ordering = ("b",)
+        self.assertChoicesEqual(
+            self.field.remote_field.get_choices(include_blank=False),
+            [self.bar2, self.bar1],
+        )
+
+
+class GetChoicesLimitChoicesToTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.foo1 = Foo.objects.create(a="a", d="12.34")
+        cls.foo2 = Foo.objects.create(a="b", d="12.34")
+        cls.bar1 = Bar.objects.create(a=cls.foo1, b="b")
+        cls.bar2 = Bar.objects.create(a=cls.foo2, b="a")
+        cls.field = Bar._meta.get_field("a")
+
+    def assertChoicesEqual(self, choices, objs):
+        self.assertCountEqual(choices, [(obj.pk, str(obj)) for obj in objs])
+
+    def test_get_choices(self):
+        self.assertChoicesEqual(
+            self.field.get_choices(include_blank=False, limit_choices_to={"a": "a"}),
+            [self.foo1],
+        )
+        self.assertChoicesEqual(
+            self.field.get_choices(include_blank=False, limit_choices_to={}),
+            [self.foo1, self.foo2],
+        )
+
+    def test_get_choices_reverse_related_field(self):
+        field = self.field.remote_field
+        self.assertChoicesEqual(
+            field.get_choices(include_blank=False, limit_choices_to={"b": "b"}),
+            [self.bar1],
+        )
+        self.assertChoicesEqual(
+            field.get_choices(include_blank=False, limit_choices_to={}),
+            [self.bar1, self.bar2],
+        )

testbed/django__django/tests/model_forms/models.py

@@ -0,0 +1,523 @@
+import datetime
+import os
+import tempfile
+import uuid
+
+from django.core import validators
+from django.core.exceptions import ValidationError
+from django.core.files.storage import FileSystemStorage
+from django.db import models
+
+temp_storage_dir = tempfile.mkdtemp()
+temp_storage = FileSystemStorage(temp_storage_dir)
+
+
+class Person(models.Model):
+    name = models.CharField(max_length=100)
+
+
+class Category(models.Model):
+    name = models.CharField(max_length=20)
+    slug = models.SlugField(max_length=20)
+    url = models.CharField("The URL", max_length=40)
+
+    class Meta:
+        ordering = ("pk",)
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.__str__()
+
+
+class WriterManager(models.Manager):
+    def get_queryset(self):
+        qs = super().get_queryset()
+        return qs.filter(archived=False)
+
+
+class Writer(models.Model):
+    name = models.CharField(max_length=50, help_text="Use both first and last names.")
+    archived = models.BooleanField(default=False, editable=False)
+
+    objects = WriterManager()
+
+    class Meta:
+        ordering = ("name",)
+
+    def __str__(self):
+        return self.name
+
+
+class Article(models.Model):
+    ARTICLE_STATUS = (
+        (1, "Draft"),
+        (2, "Pending"),
+        (3, "Live"),
+    )
+    headline = models.CharField(max_length=50)
+    slug = models.SlugField()
+    pub_date = models.DateField()
+    created = models.DateField(editable=False)
+    writer = models.ForeignKey(Writer, models.CASCADE)
+    article = models.TextField()
+    categories = models.ManyToManyField(Category, blank=True)
+    status = models.PositiveIntegerField(choices=ARTICLE_STATUS, blank=True, null=True)
+
+    def save(self, *args, **kwargs):
+        if not self.id:
+            self.created = datetime.date.today()
+        return super().save(*args, **kwargs)
+
+    def __str__(self):
+        return self.headline
+
+
+class ImprovedArticle(models.Model):
+    article = models.OneToOneField(Article, models.CASCADE)
+
+
+class ImprovedArticleWithParentLink(models.Model):
+    article = models.OneToOneField(Article, models.CASCADE, parent_link=True)
+
+
+class BetterWriter(Writer):
+    score = models.IntegerField()
+
+
+class Publication(models.Model):
+    title = models.CharField(max_length=30)
+    date_published = models.DateField()
+
+    def __str__(self):
+        return self.title
+
+
+def default_mode():
+    return "di"
+
+
+def default_category():
+    return 3
+
+
+class PublicationDefaults(models.Model):
+    MODE_CHOICES = (("di", "direct"), ("de", "delayed"))
+    CATEGORY_CHOICES = ((1, "Games"), (2, "Comics"), (3, "Novel"))
+    title = models.CharField(max_length=30)
+    date_published = models.DateField(default=datetime.date.today)
+    datetime_published = models.DateTimeField(default=datetime.datetime(2000, 1, 1))
+    mode = models.CharField(max_length=2, choices=MODE_CHOICES, default=default_mode)
+    category = models.IntegerField(choices=CATEGORY_CHOICES, default=default_category)
+    active = models.BooleanField(default=True)
+    file = models.FileField(default="default.txt")
+
+
+class Author(models.Model):
+    publication = models.OneToOneField(
+        Publication, models.SET_NULL, null=True, blank=True
+    )
+    full_name = models.CharField(max_length=255)
+
+
+class Author1(models.Model):
+    publication = models.OneToOneField(Publication, models.CASCADE, null=False)
+    full_name = models.CharField(max_length=255)
+
+
+class WriterProfile(models.Model):
+    writer = models.OneToOneField(Writer, models.CASCADE, primary_key=True)
+    age = models.PositiveIntegerField()
+
+    def __str__(self):
+        return "%s is %s" % (self.writer, self.age)
+
+
+class Document(models.Model):
+    myfile = models.FileField(upload_to="unused", blank=True)
+
+
+class TextFile(models.Model):
+    description = models.CharField(max_length=20)
+    file = models.FileField(storage=temp_storage, upload_to="tests", max_length=15)
+
+    def __str__(self):
+        return self.description
+
+
+class CustomFileField(models.FileField):
+    def save_form_data(self, instance, data):
+        been_here = getattr(self, "been_saved", False)
+        assert not been_here, "save_form_data called more than once"
+        setattr(self, "been_saved", True)
+
+
+class CustomFF(models.Model):
+    f = CustomFileField(upload_to="unused", blank=True)
+
+
+class FilePathModel(models.Model):
+    path = models.FilePathField(
+        path=os.path.dirname(__file__), match="models.py", blank=True
+    )
+
+
+try:
+    from PIL import Image  # NOQA: detect if Pillow is installed
+
+    test_images = True
+
+    class ImageFile(models.Model):
+        def custom_upload_path(self, filename):
+            path = self.path or "tests"
+            return "%s/%s" % (path, filename)
+
+        description = models.CharField(max_length=20)
+
+        # Deliberately put the image field *after* the width/height fields to
+        # trigger the bug in #10404 with width/height not getting assigned.
+        width = models.IntegerField(editable=False)
+        height = models.IntegerField(editable=False)
+        image = models.ImageField(
+            storage=temp_storage,
+            upload_to=custom_upload_path,
+            width_field="width",
+            height_field="height",
+        )
+        path = models.CharField(max_length=16, blank=True, default="")
+
+        def __str__(self):
+            return self.description
+
+    class OptionalImageFile(models.Model):
+        def custom_upload_path(self, filename):
+            path = self.path or "tests"
+            return "%s/%s" % (path, filename)
+
+        description = models.CharField(max_length=20)
+        image = models.ImageField(
+            storage=temp_storage,
+            upload_to=custom_upload_path,
+            width_field="width",
+            height_field="height",
+            blank=True,
+            null=True,
+        )
+        width = models.IntegerField(editable=False, null=True)
+        height = models.IntegerField(editable=False, null=True)
+        path = models.CharField(max_length=16, blank=True, default="")
+
+        def __str__(self):
+            return self.description
+
+    class NoExtensionImageFile(models.Model):
+        def upload_to(self, filename):
+            return "tests/no_extension"
+
+        description = models.CharField(max_length=20)
+        image = models.ImageField(storage=temp_storage, upload_to=upload_to)
+
+        def __str__(self):
+            return self.description
+
+except ImportError:
+    test_images = False
+
+
+class Homepage(models.Model):
+    url = models.URLField()
+
+
+class Product(models.Model):
+    slug = models.SlugField(unique=True)
+
+    def __str__(self):
+        return self.slug
+
+
+class Price(models.Model):
+    price = models.DecimalField(max_digits=10, decimal_places=2)
+    quantity = models.PositiveIntegerField()
+
+    class Meta:
+        unique_together = (("price", "quantity"),)
+
+    def __str__(self):
+        return "%s for %s" % (self.quantity, self.price)
+
+
+class Triple(models.Model):
+    left = models.IntegerField()
+    middle = models.IntegerField()
+    right = models.IntegerField()
+
+    class Meta:
+        unique_together = (("left", "middle"), ("middle", "right"))
+
+
+class ArticleStatus(models.Model):
+    ARTICLE_STATUS_CHAR = (
+        ("d", "Draft"),
+        ("p", "Pending"),
+        ("l", "Live"),
+    )
+    status = models.CharField(
+        max_length=2, choices=ARTICLE_STATUS_CHAR, blank=True, null=True
+    )
+
+
+class Inventory(models.Model):
+    barcode = models.PositiveIntegerField(unique=True)
+    parent = models.ForeignKey(
+        "self", models.SET_NULL, to_field="barcode", blank=True, null=True
+    )
+    name = models.CharField(blank=False, max_length=20)
+
+    class Meta:
+        ordering = ("name",)
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.__str__()
+
+
+class Book(models.Model):
+    title = models.CharField(max_length=40)
+    author = models.ForeignKey(Writer, models.SET_NULL, blank=True, null=True)
+    special_id = models.IntegerField(blank=True, null=True, unique=True)
+
+    class Meta:
+        unique_together = ("title", "author")
+
+
+class BookXtra(models.Model):
+    isbn = models.CharField(max_length=16, unique=True)
+    suffix1 = models.IntegerField(blank=True, default=0)
+    suffix2 = models.IntegerField(blank=True, default=0)
+
+    class Meta:
+        unique_together = ("suffix1", "suffix2")
+        abstract = True
+
+
+class DerivedBook(Book, BookXtra):
+    pass
+
+
+class ExplicitPK(models.Model):
+    key = models.CharField(max_length=20, primary_key=True)
+    desc = models.CharField(max_length=20, blank=True, unique=True)
+
+    class Meta:
+        unique_together = ("key", "desc")
+
+    def __str__(self):
+        return self.key
+
+
+class Post(models.Model):
+    title = models.CharField(max_length=50, unique_for_date="posted", blank=True)
+    slug = models.CharField(max_length=50, unique_for_year="posted", blank=True)
+    subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True)
+    posted = models.DateField()
+
+    def __str__(self):
+        return self.title
+
+
+class DateTimePost(models.Model):
+    title = models.CharField(max_length=50, unique_for_date="posted", blank=True)
+    slug = models.CharField(max_length=50, unique_for_year="posted", blank=True)
+    subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True)
+    posted = models.DateTimeField(editable=False)
+
+    def __str__(self):
+        return self.title
+
+
+class DerivedPost(Post):
+    pass
+
+
+class BigInt(models.Model):
+    biggie = models.BigIntegerField()
+
+    def __str__(self):
+        return str(self.biggie)
+
+
+class MarkupField(models.CharField):
+    def __init__(self, *args, **kwargs):
+        kwargs["max_length"] = 20
+        super().__init__(*args, **kwargs)
+
+    def formfield(self, **kwargs):
+        # don't allow this field to be used in form (real use-case might be
+        # that you know the markup will always be X, but it is among an app
+        # that allows the user to say it could be something else)
+        # regressed at r10062
+        return None
+
+
+class CustomFieldForExclusionModel(models.Model):
+    name = models.CharField(max_length=10)
+    markup = MarkupField()
+
+
+class FlexibleDatePost(models.Model):
+    title = models.CharField(max_length=50, unique_for_date="posted", blank=True)
+    slug = models.CharField(max_length=50, unique_for_year="posted", blank=True)
+    subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True)
+    posted = models.DateField(blank=True, null=True)
+
+
+class Colour(models.Model):
+    name = models.CharField(max_length=50)
+
+    def __iter__(self):
+        yield from range(5)
+
+    def __str__(self):
+        return self.name
+
+
+class ColourfulItem(models.Model):
+    name = models.CharField(max_length=50)
+    colours = models.ManyToManyField(Colour)
+
+
+class CustomErrorMessage(models.Model):
+    name1 = models.CharField(
+        max_length=50,
+        validators=[validators.validate_slug],
+        error_messages={"invalid": "Model custom error message."},
+    )
+    name2 = models.CharField(
+        max_length=50,
+        validators=[validators.validate_slug],
+        error_messages={"invalid": "Model custom error message."},
+    )
+
+    def clean(self):
+        if self.name1 == "FORBIDDEN_VALUE":
+            raise ValidationError(
+                {"name1": [ValidationError("Model.clean() error messages.")]}
+            )
+        elif self.name1 == "FORBIDDEN_VALUE2":
+            raise ValidationError(
+                {"name1": "Model.clean() error messages (simpler syntax)."}
+            )
+        elif self.name1 == "GLOBAL_ERROR":
+            raise ValidationError("Global error message.")
+
+
+def today_callable_dict():
+    return {"last_action__gte": datetime.datetime.today()}
+
+
+def today_callable_q():
+    return models.Q(last_action__gte=datetime.datetime.today())
+
+
+class Character(models.Model):
+    username = models.CharField(max_length=100)
+    last_action = models.DateTimeField()
+
+    def __str__(self):
+        return self.username
+
+
+class StumpJoke(models.Model):
+    most_recently_fooled = models.ForeignKey(
+        Character,
+        models.CASCADE,
+        limit_choices_to=today_callable_dict,
+        related_name="jokes",
+    )
+    has_fooled_today = models.ManyToManyField(
+        Character,
+        limit_choices_to=today_callable_q,
+        related_name="jokes_today",
+    )
+    funny = models.BooleanField(default=False)
+
+
+# Model for #13776
+class Student(models.Model):
+    character = models.ForeignKey(Character, models.CASCADE)
+    study = models.CharField(max_length=30)
+
+
+# Model for #639
+class Photo(models.Model):
+    title = models.CharField(max_length=30)
+    image = models.FileField(storage=temp_storage, upload_to="tests")
+
+    # Support code for the tests; this keeps track of how many times save()
+    # gets called on each instance.
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._savecount = 0
+
+    def save(self, force_insert=False, force_update=False):
+        super().save(force_insert, force_update)
+        self._savecount += 1
+
+
+class UUIDPK(models.Model):
+    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=30)
+
+
+# Models for #24706
+class StrictAssignmentFieldSpecific(models.Model):
+    title = models.CharField(max_length=30)
+    _should_error = False
+
+    def __setattr__(self, key, value):
+        if self._should_error is True:
+            raise ValidationError(message={key: "Cannot set attribute"}, code="invalid")
+        super().__setattr__(key, value)
+
+
+class StrictAssignmentAll(models.Model):
+    title = models.CharField(max_length=30)
+    _should_error = False
+
+    def __setattr__(self, key, value):
+        if self._should_error is True:
+            raise ValidationError(message="Cannot set attribute", code="invalid")
+        super().__setattr__(key, value)
+
+
+# A model with ForeignKey(blank=False, null=True)
+class Award(models.Model):
+    name = models.CharField(max_length=30)
+    character = models.ForeignKey(Character, models.SET_NULL, blank=False, null=True)
+
+
+class NullableUniqueCharFieldModel(models.Model):
+    codename = models.CharField(max_length=50, blank=True, null=True, unique=True)
+    email = models.EmailField(blank=True, null=True)
+    slug = models.SlugField(blank=True, null=True)
+    url = models.URLField(blank=True, null=True)
+
+
+class Number(models.Model):
+    value = models.IntegerField()
+
+
+class NumbersToDice(models.Model):
+    number = models.ForeignKey("Number", on_delete=models.CASCADE)
+    die = models.ForeignKey("Dice", on_delete=models.CASCADE)
+
+
+class Dice(models.Model):
+    numbers = models.ManyToManyField(
+        Number,
+        through=NumbersToDice,
+        limit_choices_to=models.Q(value__gte=1),
+    )

testbed/django__django/tests/model_forms/test_uuid.py

@@ -0,0 +1,35 @@
+from django import forms
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+
+from .models import UUIDPK
+
+
+class UUIDPKForm(forms.ModelForm):
+    class Meta:
+        model = UUIDPK
+        fields = "__all__"
+
+
+class ModelFormBaseTest(TestCase):
+    def test_create_save_error(self):
+        form = UUIDPKForm({})
+        self.assertFalse(form.is_valid())
+        msg = "The UUIDPK could not be created because the data didn't validate."
+        with self.assertRaisesMessage(ValueError, msg):
+            form.save()
+
+    def test_update_save_error(self):
+        obj = UUIDPK.objects.create(name="foo")
+        form = UUIDPKForm({}, instance=obj)
+        self.assertFalse(form.is_valid())
+        msg = "The UUIDPK could not be changed because the data didn't validate."
+        with self.assertRaisesMessage(ValueError, msg):
+            form.save()
+
+    def test_model_multiple_choice_field_uuid_pk(self):
+        f = forms.ModelMultipleChoiceField(UUIDPK.objects.all())
+        with self.assertRaisesMessage(
+            ValidationError, "“invalid_uuid” is not a valid UUID."
+        ):
+            f.clean(["invalid_uuid"])

testbed/django__django/tests/model_formsets/models.py

@@ -0,0 +1,265 @@
+import datetime
+import uuid
+
+from django.db import models
+
+
+class Author(models.Model):
+    name = models.CharField(max_length=100)
+
+    class Meta:
+        ordering = ("name",)
+
+    def __str__(self):
+        return self.name
+
+
+class BetterAuthor(Author):
+    write_speed = models.IntegerField()
+
+
+class Book(models.Model):
+    author = models.ForeignKey(Author, models.CASCADE)
+    title = models.CharField(max_length=100)
+
+    class Meta:
+        unique_together = (("author", "title"),)
+        ordering = ["id"]
+
+    def __str__(self):
+        return self.title
+
+    def clean(self):
+        # Ensure author is always accessible in clean method
+        assert self.author.name is not None
+
+
+class BookWithCustomPK(models.Model):
+    my_pk = models.DecimalField(max_digits=5, decimal_places=0, primary_key=True)
+    author = models.ForeignKey(Author, models.CASCADE)
+    title = models.CharField(max_length=100)
+
+    def __str__(self):
+        return "%s: %s" % (self.my_pk, self.title)
+
+
+class Editor(models.Model):
+    name = models.CharField(max_length=100)
+
+
+class BookWithOptionalAltEditor(models.Model):
+    author = models.ForeignKey(Author, models.CASCADE)
+    # Optional secondary author
+    alt_editor = models.ForeignKey(Editor, models.SET_NULL, blank=True, null=True)
+    title = models.CharField(max_length=100)
+
+    class Meta:
+        unique_together = (("author", "title", "alt_editor"),)
+
+    def __str__(self):
+        return self.title
+
+
+class AlternateBook(Book):
+    notes = models.CharField(max_length=100)
+
+    def __str__(self):
+        return "%s - %s" % (self.title, self.notes)
+
+
+class AuthorMeeting(models.Model):
+    name = models.CharField(max_length=100)
+    authors = models.ManyToManyField(Author)
+    created = models.DateField(editable=False)
+
+    def __str__(self):
+        return self.name
+
+
+class CustomPrimaryKey(models.Model):
+    my_pk = models.CharField(max_length=10, primary_key=True)
+    some_field = models.CharField(max_length=100)
+
+
+# models for inheritance tests.
+
+
+class Place(models.Model):
+    name = models.CharField(max_length=50)
+    city = models.CharField(max_length=50)
+
+    def __str__(self):
+        return self.name
+
+
+class Owner(models.Model):
+    auto_id = models.AutoField(primary_key=True)
+    name = models.CharField(max_length=100)
+    place = models.ForeignKey(Place, models.CASCADE)
+
+    def __str__(self):
+        return "%s at %s" % (self.name, self.place)
+
+
+class Location(models.Model):
+    place = models.ForeignKey(Place, models.CASCADE, unique=True)
+    # this is purely for testing the data doesn't matter here :)
+    lat = models.CharField(max_length=100)
+    lon = models.CharField(max_length=100)
+
+
+class OwnerProfile(models.Model):
+    owner = models.OneToOneField(Owner, models.CASCADE, primary_key=True)
+    age = models.PositiveIntegerField()
+
+    def __str__(self):
+        return "%s is %d" % (self.owner.name, self.age)
+
+
+class Restaurant(Place):
+    serves_pizza = models.BooleanField(default=False)
+
+
+class Product(models.Model):
+    slug = models.SlugField(unique=True)
+
+    def __str__(self):
+        return self.slug
+
+
+class Price(models.Model):
+    price = models.DecimalField(max_digits=10, decimal_places=2)
+    quantity = models.PositiveIntegerField()
+
+    class Meta:
+        unique_together = (("price", "quantity"),)
+
+    def __str__(self):
+        return "%s for %s" % (self.quantity, self.price)
+
+
+class MexicanRestaurant(Restaurant):
+    serves_tacos = models.BooleanField(default=False)
+
+
+class ClassyMexicanRestaurant(MexicanRestaurant):
+    the_restaurant = models.OneToOneField(
+        MexicanRestaurant, models.CASCADE, parent_link=True, primary_key=True
+    )
+    tacos_are_yummy = models.BooleanField(default=False)
+
+
+# models for testing unique_together validation when a fk is involved and
+# using inlineformset_factory.
+class Repository(models.Model):
+    name = models.CharField(max_length=25)
+
+    def __str__(self):
+        return self.name
+
+
+class Revision(models.Model):
+    repository = models.ForeignKey(Repository, models.CASCADE)
+    revision = models.CharField(max_length=40)
+
+    class Meta:
+        unique_together = (("repository", "revision"),)
+
+    def __str__(self):
+        return "%s (%s)" % (self.revision, str(self.repository))
+
+
+# models for testing callable defaults (see bug #7975). If you define a model
+# with a callable default value, you cannot rely on the initial value in a
+# form.
+class Person(models.Model):
+    name = models.CharField(max_length=128)
+
+
+class Membership(models.Model):
+    person = models.ForeignKey(Person, models.CASCADE)
+    date_joined = models.DateTimeField(default=datetime.datetime.now)
+    karma = models.IntegerField()
+
+
+# models for testing a null=True fk to a parent
+class Team(models.Model):
+    name = models.CharField(max_length=100)
+
+
+class Player(models.Model):
+    team = models.ForeignKey(Team, models.SET_NULL, null=True)
+    name = models.CharField(max_length=100)
+
+    def __str__(self):
+        return self.name
+
+
+# Models for testing custom ModelForm save methods in formsets and inline formsets
+class Poet(models.Model):
+    name = models.CharField(max_length=100)
+
+    def __str__(self):
+        return self.name
+
+
+class Poem(models.Model):
+    poet = models.ForeignKey(Poet, models.CASCADE)
+    name = models.CharField(max_length=100)
+
+    def __str__(self):
+        return self.name
+
+
+class Post(models.Model):
+    title = models.CharField(max_length=50, unique_for_date="posted", blank=True)
+    slug = models.CharField(max_length=50, unique_for_year="posted", blank=True)
+    subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True)
+    posted = models.DateField()
+
+    def __str__(self):
+        return self.title
+
+
+# Models for testing UUID primary keys
+class UUIDPKParent(models.Model):
+    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=255)
+
+
+class UUIDPKChild(models.Model):
+    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=255)
+    parent = models.ForeignKey(UUIDPKParent, models.CASCADE)
+
+
+class ChildWithEditablePK(models.Model):
+    name = models.CharField(max_length=255, primary_key=True)
+    parent = models.ForeignKey(UUIDPKParent, models.CASCADE)
+
+
+class AutoPKChildOfUUIDPKParent(models.Model):
+    name = models.CharField(max_length=255)
+    parent = models.ForeignKey(UUIDPKParent, models.CASCADE)
+
+
+class AutoPKParent(models.Model):
+    name = models.CharField(max_length=255)
+
+
+class UUIDPKChildOfAutoPKParent(models.Model):
+    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=255)
+    parent = models.ForeignKey(AutoPKParent, models.CASCADE)
+
+
+class ParentWithUUIDAlternateKey(models.Model):
+    uuid = models.UUIDField(unique=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=50)
+
+
+class ChildRelatedViaAK(models.Model):
+    name = models.CharField(max_length=255)
+    parent = models.ForeignKey(
+        ParentWithUUIDAlternateKey, models.CASCADE, to_field="uuid"
+    )

testbed/django__django/tests/model_formsets/test_uuid.py

@@ -0,0 +1,117 @@
+from django.forms.models import inlineformset_factory
+from django.test import TestCase
+
+from .models import (
+    AutoPKChildOfUUIDPKParent,
+    AutoPKParent,
+    ChildRelatedViaAK,
+    ChildWithEditablePK,
+    ParentWithUUIDAlternateKey,
+    UUIDPKChild,
+    UUIDPKChildOfAutoPKParent,
+    UUIDPKParent,
+)
+
+
+class InlineFormsetTests(TestCase):
+    def test_inlineformset_factory_nulls_default_pks(self):
+        """
+        #24377 - If we're adding a new object, a parent's auto-generated pk
+        from the model field default should be ignored as it's regenerated on
+        the save request.
+
+        Tests the case where both the parent and child have a UUID primary key.
+        """
+        FormSet = inlineformset_factory(UUIDPKParent, UUIDPKChild, fields="__all__")
+        formset = FormSet()
+        self.assertIsNone(formset.forms[0].fields["parent"].initial)
+
+    def test_inlineformset_factory_ignores_default_pks_on_submit(self):
+        """
+        #24377 - Inlines with a model field default should ignore that default
+        value to avoid triggering validation on empty forms.
+        """
+        FormSet = inlineformset_factory(UUIDPKParent, UUIDPKChild, fields="__all__")
+        formset = FormSet(
+            {
+                "uuidpkchild_set-TOTAL_FORMS": 3,
+                "uuidpkchild_set-INITIAL_FORMS": 0,
+                "uuidpkchild_set-MAX_NUM_FORMS": "",
+                "uuidpkchild_set-0-name": "Foo",
+                "uuidpkchild_set-1-name": "",
+                "uuidpkchild_set-2-name": "",
+            }
+        )
+        self.assertTrue(formset.is_valid())
+        self.assertIsNone(formset.instance.uuid)
+        self.assertIsNone(formset.forms[0].instance.parent_id)
+
+    def test_inlineformset_factory_nulls_default_pks_uuid_parent_auto_child(self):
+        """
+        #24958 - Variant of test_inlineformset_factory_nulls_default_pks for
+        the case of a parent object with a UUID primary key and a child object
+        with an AutoField primary key.
+        """
+        FormSet = inlineformset_factory(
+            UUIDPKParent, AutoPKChildOfUUIDPKParent, fields="__all__"
+        )
+        formset = FormSet()
+        self.assertIsNone(formset.forms[0].fields["parent"].initial)
+
+    def test_inlineformset_factory_nulls_default_pks_auto_parent_uuid_child(self):
+        """
+        #24958 - Variant of test_inlineformset_factory_nulls_default_pks for
+        the case of a parent object with an AutoField primary key and a child
+        object with a UUID primary key.
+        """
+        FormSet = inlineformset_factory(
+            AutoPKParent, UUIDPKChildOfAutoPKParent, fields="__all__"
+        )
+        formset = FormSet()
+        self.assertIsNone(formset.forms[0].fields["parent"].initial)
+
+    def test_inlineformset_factory_nulls_default_pks_child_editable_pk(self):
+        """
+        #24958 - Variant of test_inlineformset_factory_nulls_default_pks for
+        the case of a parent object with a UUID primary key and a child
+        object with an editable natural key for a primary key.
+        """
+        FormSet = inlineformset_factory(
+            UUIDPKParent, ChildWithEditablePK, fields="__all__"
+        )
+        formset = FormSet()
+        self.assertIsNone(formset.forms[0].fields["parent"].initial)
+
+    def test_inlineformset_factory_nulls_default_pks_alternate_key_relation(self):
+        """
+        #24958 - Variant of test_inlineformset_factory_nulls_default_pks for
+        the case of a parent object with a UUID alternate key and a child
+        object that relates to that alternate key.
+        """
+        FormSet = inlineformset_factory(
+            ParentWithUUIDAlternateKey, ChildRelatedViaAK, fields="__all__"
+        )
+        formset = FormSet()
+        self.assertIsNone(formset.forms[0].fields["parent"].initial)
+
+    def test_inlineformset_factory_nulls_default_pks_alternate_key_relation_data(self):
+        """
+        If form data is provided, a parent's auto-generated alternate key is
+        set.
+        """
+        FormSet = inlineformset_factory(
+            ParentWithUUIDAlternateKey, ChildRelatedViaAK, fields="__all__"
+        )
+        formset = FormSet(
+            {
+                "childrelatedviaak_set-TOTAL_FORMS": 3,
+                "childrelatedviaak_set-INITIAL_FORMS": 0,
+                "childrelatedviaak_set-MAX_NUM_FORMS": "",
+                "childrelatedviaak_set-0-name": "Test",
+                "childrelatedviaak_set-1-name": "",
+                "childrelatedviaak_set-2-name": "",
+            }
+        )
+        self.assertIs(formset.is_valid(), True)
+        self.assertIsNotNone(formset.instance.uuid)
+        self.assertEqual(formset.forms[0].instance.parent_id, formset.instance.uuid)

testbed/django__django/tests/model_formsets/tests.py

@@ -0,0 +1,2367 @@
+import datetime
+import re
+from datetime import date
+from decimal import Decimal
+
+from django import forms
+from django.core.exceptions import ImproperlyConfigured
+from django.db import models
+from django.forms.formsets import formset_factory
+from django.forms.models import (
+    BaseModelFormSet,
+    _get_foreign_key,
+    inlineformset_factory,
+    modelformset_factory,
+)
+from django.http import QueryDict
+from django.test import TestCase, skipUnlessDBFeature
+
+from .models import (
+    AlternateBook,
+    Author,
+    AuthorMeeting,
+    BetterAuthor,
+    Book,
+    BookWithCustomPK,
+    BookWithOptionalAltEditor,
+    ClassyMexicanRestaurant,
+    CustomPrimaryKey,
+    Location,
+    Membership,
+    MexicanRestaurant,
+    Owner,
+    OwnerProfile,
+    Person,
+    Place,
+    Player,
+    Poem,
+    Poet,
+    Post,
+    Price,
+    Product,
+    Repository,
+    Restaurant,
+    Revision,
+    Team,
+)
+
+
+class DeletionTests(TestCase):
+    def test_deletion(self):
+        PoetFormSet = modelformset_factory(Poet, fields="__all__", can_delete=True)
+        poet = Poet.objects.create(name="test")
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "0",
+            "form-0-id": str(poet.pk),
+            "form-0-name": "test",
+            "form-0-DELETE": "on",
+        }
+        formset = PoetFormSet(data, queryset=Poet.objects.all())
+        formset.save(commit=False)
+        self.assertEqual(Poet.objects.count(), 1)
+
+        formset.save()
+        self.assertTrue(formset.is_valid())
+        self.assertEqual(Poet.objects.count(), 0)
+
+    def test_add_form_deletion_when_invalid(self):
+        """
+        Make sure that an add form that is filled out, but marked for deletion
+        doesn't cause validation errors.
+        """
+        PoetFormSet = modelformset_factory(Poet, fields="__all__", can_delete=True)
+        poet = Poet.objects.create(name="test")
+        # One existing untouched and two new unvalid forms
+        data = {
+            "form-TOTAL_FORMS": "3",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "0",
+            "form-0-id": str(poet.id),
+            "form-0-name": "test",
+            "form-1-id": "",
+            "form-1-name": "x" * 1000,  # Too long
+            "form-2-id": str(poet.id),  # Violate unique constraint
+            "form-2-name": "test2",
+        }
+        formset = PoetFormSet(data, queryset=Poet.objects.all())
+        # Make sure this form doesn't pass validation.
+        self.assertIs(formset.is_valid(), False)
+        self.assertEqual(Poet.objects.count(), 1)
+
+        # Then make sure that it *does* pass validation and delete the object,
+        # even though the data in new forms aren't actually valid.
+        data["form-0-DELETE"] = "on"
+        data["form-1-DELETE"] = "on"
+        data["form-2-DELETE"] = "on"
+        formset = PoetFormSet(data, queryset=Poet.objects.all())
+        self.assertIs(formset.is_valid(), True)
+        formset.save()
+        self.assertEqual(Poet.objects.count(), 0)
+
+    def test_change_form_deletion_when_invalid(self):
+        """
+        Make sure that a change form that is filled out, but marked for deletion
+        doesn't cause validation errors.
+        """
+        PoetFormSet = modelformset_factory(Poet, fields="__all__", can_delete=True)
+        poet = Poet.objects.create(name="test")
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "0",
+            "form-0-id": str(poet.id),
+            "form-0-name": "x" * 1000,
+        }
+        formset = PoetFormSet(data, queryset=Poet.objects.all())
+        # Make sure this form doesn't pass validation.
+        self.assertIs(formset.is_valid(), False)
+        self.assertEqual(Poet.objects.count(), 1)
+
+        # Then make sure that it *does* pass validation and delete the object,
+        # even though the data isn't actually valid.
+        data["form-0-DELETE"] = "on"
+        formset = PoetFormSet(data, queryset=Poet.objects.all())
+        self.assertIs(formset.is_valid(), True)
+        formset.save()
+        self.assertEqual(Poet.objects.count(), 0)
+
+    def test_outdated_deletion(self):
+        poet = Poet.objects.create(name="test")
+        poem = Poem.objects.create(name="Brevity is the soul of wit", poet=poet)
+
+        PoemFormSet = inlineformset_factory(
+            Poet, Poem, fields="__all__", can_delete=True
+        )
+
+        # Simulate deletion of an object that doesn't exist in the database
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "2",
+            "form-0-id": str(poem.pk),
+            "form-0-name": "foo",
+            "form-1-id": str(poem.pk + 1),  # doesn't exist
+            "form-1-name": "bar",
+            "form-1-DELETE": "on",
+        }
+        formset = PoemFormSet(data, instance=poet, prefix="form")
+
+        # The formset is valid even though poem.pk + 1 doesn't exist,
+        # because it's marked for deletion anyway
+        self.assertTrue(formset.is_valid())
+
+        formset.save()
+
+        # Make sure the save went through correctly
+        self.assertEqual(Poem.objects.get(pk=poem.pk).name, "foo")
+        self.assertEqual(poet.poem_set.count(), 1)
+        self.assertFalse(Poem.objects.filter(pk=poem.pk + 1).exists())
+
+
+class ModelFormsetTest(TestCase):
+    def test_modelformset_factory_without_fields(self):
+        """Regression for #19733"""
+        message = (
+            "Calling modelformset_factory without defining 'fields' or 'exclude' "
+            "explicitly is prohibited."
+        )
+        with self.assertRaisesMessage(ImproperlyConfigured, message):
+            modelformset_factory(Author)
+
+    def test_simple_save(self):
+        qs = Author.objects.all()
+        AuthorFormSet = modelformset_factory(Author, fields="__all__", extra=3)
+
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 3)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_form-0-name">Name:</label>'
+            '<input id="id_form-0-name" type="text" name="form-0-name" maxlength="100">'
+            '<input type="hidden" name="form-0-id" id="id_form-0-id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_form-1-name">Name:</label>'
+            '<input id="id_form-1-name" type="text" name="form-1-name" maxlength="100">'
+            '<input type="hidden" name="form-1-id" id="id_form-1-id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_form-2-name">Name:</label>'
+            '<input id="id_form-2-name" type="text" name="form-2-name" maxlength="100">'
+            '<input type="hidden" name="form-2-id" id="id_form-2-id"></p>',
+        )
+
+        data = {
+            "form-TOTAL_FORMS": "3",  # the number of forms rendered
+            "form-INITIAL_FORMS": "0",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-name": "Charles Baudelaire",
+            "form-1-name": "Arthur Rimbaud",
+            "form-2-name": "",
+        }
+
+        formset = AuthorFormSet(data=data, queryset=qs)
+        self.assertTrue(formset.is_valid())
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 2)
+        author1, author2 = saved
+        self.assertEqual(author1, Author.objects.get(name="Charles Baudelaire"))
+        self.assertEqual(author2, Author.objects.get(name="Arthur Rimbaud"))
+
+        authors = list(Author.objects.order_by("name"))
+        self.assertEqual(authors, [author2, author1])
+
+        # Gah! We forgot Paul Verlaine. Let's create a formset to edit the
+        # existing authors with an extra form to add him. We *could* pass in a
+        # queryset to restrict the Author objects we edit, but in this case
+        # we'll use it to display them in alphabetical order by name.
+
+        qs = Author.objects.order_by("name")
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", extra=1, can_delete=False
+        )
+
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 3)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_form-0-name">Name:</label>'
+            '<input id="id_form-0-name" type="text" name="form-0-name" '
+            'value="Arthur Rimbaud" maxlength="100">'
+            '<input type="hidden" name="form-0-id" value="%d" id="id_form-0-id"></p>'
+            % author2.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_form-1-name">Name:</label>'
+            '<input id="id_form-1-name" type="text" name="form-1-name" '
+            'value="Charles Baudelaire" maxlength="100">'
+            '<input type="hidden" name="form-1-id" value="%d" id="id_form-1-id"></p>'
+            % author1.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_form-2-name">Name:</label>'
+            '<input id="id_form-2-name" type="text" name="form-2-name" maxlength="100">'
+            '<input type="hidden" name="form-2-id" id="id_form-2-id"></p>',
+        )
+
+        data = {
+            "form-TOTAL_FORMS": "3",  # the number of forms rendered
+            "form-INITIAL_FORMS": "2",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-id": str(author2.id),
+            "form-0-name": "Arthur Rimbaud",
+            "form-1-id": str(author1.id),
+            "form-1-name": "Charles Baudelaire",
+            "form-2-name": "Paul Verlaine",
+        }
+
+        formset = AuthorFormSet(data=data, queryset=qs)
+        self.assertTrue(formset.is_valid())
+
+        # Only changed or new objects are returned from formset.save()
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        author3 = saved[0]
+        self.assertEqual(author3, Author.objects.get(name="Paul Verlaine"))
+
+        authors = list(Author.objects.order_by("name"))
+        self.assertEqual(authors, [author2, author1, author3])
+
+        # This probably shouldn't happen, but it will. If an add form was
+        # marked for deletion, make sure we don't save that form.
+
+        qs = Author.objects.order_by("name")
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", extra=1, can_delete=True
+        )
+
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 4)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_form-0-name">Name:</label>'
+            '<input id="id_form-0-name" type="text" name="form-0-name" '
+            'value="Arthur Rimbaud" maxlength="100"></p>'
+            '<p><label for="id_form-0-DELETE">Delete:</label>'
+            '<input type="checkbox" name="form-0-DELETE" id="id_form-0-DELETE">'
+            '<input type="hidden" name="form-0-id" value="%d" id="id_form-0-id"></p>'
+            % author2.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_form-1-name">Name:</label>'
+            '<input id="id_form-1-name" type="text" name="form-1-name" '
+            'value="Charles Baudelaire" maxlength="100"></p>'
+            '<p><label for="id_form-1-DELETE">Delete:</label>'
+            '<input type="checkbox" name="form-1-DELETE" id="id_form-1-DELETE">'
+            '<input type="hidden" name="form-1-id" value="%d" id="id_form-1-id"></p>'
+            % author1.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_form-2-name">Name:</label>'
+            '<input id="id_form-2-name" type="text" name="form-2-name" '
+            'value="Paul Verlaine" maxlength="100"></p>'
+            '<p><label for="id_form-2-DELETE">Delete:</label>'
+            '<input type="checkbox" name="form-2-DELETE" id="id_form-2-DELETE">'
+            '<input type="hidden" name="form-2-id" value="%d" id="id_form-2-id"></p>'
+            % author3.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[3].as_p(),
+            '<p><label for="id_form-3-name">Name:</label>'
+            '<input id="id_form-3-name" type="text" name="form-3-name" maxlength="100">'
+            '</p><p><label for="id_form-3-DELETE">Delete:</label>'
+            '<input type="checkbox" name="form-3-DELETE" id="id_form-3-DELETE">'
+            '<input type="hidden" name="form-3-id" id="id_form-3-id"></p>',
+        )
+
+        data = {
+            "form-TOTAL_FORMS": "4",  # the number of forms rendered
+            "form-INITIAL_FORMS": "3",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-id": str(author2.id),
+            "form-0-name": "Arthur Rimbaud",
+            "form-1-id": str(author1.id),
+            "form-1-name": "Charles Baudelaire",
+            "form-2-id": str(author3.id),
+            "form-2-name": "Paul Verlaine",
+            "form-3-name": "Walt Whitman",
+            "form-3-DELETE": "on",
+        }
+
+        formset = AuthorFormSet(data=data, queryset=qs)
+        self.assertTrue(formset.is_valid())
+
+        # No objects were changed or saved so nothing will come back.
+
+        self.assertEqual(formset.save(), [])
+
+        authors = list(Author.objects.order_by("name"))
+        self.assertEqual(authors, [author2, author1, author3])
+
+        # Let's edit a record to ensure save only returns that one record.
+
+        data = {
+            "form-TOTAL_FORMS": "4",  # the number of forms rendered
+            "form-INITIAL_FORMS": "3",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-id": str(author2.id),
+            "form-0-name": "Walt Whitman",
+            "form-1-id": str(author1.id),
+            "form-1-name": "Charles Baudelaire",
+            "form-2-id": str(author3.id),
+            "form-2-name": "Paul Verlaine",
+            "form-3-name": "",
+            "form-3-DELETE": "",
+        }
+
+        formset = AuthorFormSet(data=data, queryset=qs)
+        self.assertTrue(formset.is_valid())
+
+        # One record has changed.
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        self.assertEqual(saved[0], Author.objects.get(name="Walt Whitman"))
+
+    def test_commit_false(self):
+        # Test the behavior of commit=False and save_m2m
+
+        author1 = Author.objects.create(name="Charles Baudelaire")
+        author2 = Author.objects.create(name="Paul Verlaine")
+        author3 = Author.objects.create(name="Walt Whitman")
+
+        meeting = AuthorMeeting.objects.create(created=date.today())
+        meeting.authors.set(Author.objects.all())
+
+        # create an Author instance to add to the meeting.
+
+        author4 = Author.objects.create(name="John Steinbeck")
+
+        AuthorMeetingFormSet = modelformset_factory(
+            AuthorMeeting, fields="__all__", extra=1, can_delete=True
+        )
+        data = {
+            "form-TOTAL_FORMS": "2",  # the number of forms rendered
+            "form-INITIAL_FORMS": "1",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-id": str(meeting.id),
+            "form-0-name": "2nd Tuesday of the Week Meeting",
+            "form-0-authors": [author2.id, author1.id, author3.id, author4.id],
+            "form-1-name": "",
+            "form-1-authors": "",
+            "form-1-DELETE": "",
+        }
+        formset = AuthorMeetingFormSet(data=data, queryset=AuthorMeeting.objects.all())
+        self.assertTrue(formset.is_valid())
+
+        instances = formset.save(commit=False)
+        for instance in instances:
+            instance.created = date.today()
+            instance.save()
+        formset.save_m2m()
+        self.assertSequenceEqual(
+            instances[0].authors.all(),
+            [author1, author4, author2, author3],
+        )
+
+    def test_max_num(self):
+        # Test the behavior of max_num with model formsets. It should allow
+        # all existing related objects/inlines for a given object to be
+        # displayed, but not allow the creation of new inlines beyond max_num.
+
+        a1 = Author.objects.create(name="Charles Baudelaire")
+        a2 = Author.objects.create(name="Paul Verlaine")
+        a3 = Author.objects.create(name="Walt Whitman")
+
+        qs = Author.objects.order_by("name")
+
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", max_num=None, extra=3
+        )
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 6)
+        self.assertEqual(len(formset.extra_forms), 3)
+
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", max_num=4, extra=3
+        )
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 4)
+        self.assertEqual(len(formset.extra_forms), 1)
+
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", max_num=0, extra=3
+        )
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 3)
+        self.assertEqual(len(formset.extra_forms), 0)
+
+        AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=None)
+        formset = AuthorFormSet(queryset=qs)
+        self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3])
+
+        AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=0)
+        formset = AuthorFormSet(queryset=qs)
+        self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3])
+
+        AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=4)
+        formset = AuthorFormSet(queryset=qs)
+        self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3])
+
+    def test_min_num(self):
+        # Test the behavior of min_num with model formsets. It should be
+        # added to extra.
+        qs = Author.objects.none()
+
+        AuthorFormSet = modelformset_factory(Author, fields="__all__", extra=0)
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 0)
+
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", min_num=1, extra=0
+        )
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 1)
+
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", min_num=1, extra=1
+        )
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 2)
+
+    def test_min_num_with_existing(self):
+        # Test the behavior of min_num with existing objects.
+        Author.objects.create(name="Charles Baudelaire")
+        qs = Author.objects.all()
+
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", extra=0, min_num=1
+        )
+        formset = AuthorFormSet(queryset=qs)
+        self.assertEqual(len(formset.forms), 1)
+
+    def test_custom_save_method(self):
+        class PoetForm(forms.ModelForm):
+            def save(self, commit=True):
+                # change the name to "Vladimir Mayakovsky" just to be a jerk.
+                author = super().save(commit=False)
+                author.name = "Vladimir Mayakovsky"
+                if commit:
+                    author.save()
+                return author
+
+        PoetFormSet = modelformset_factory(Poet, fields="__all__", form=PoetForm)
+
+        data = {
+            "form-TOTAL_FORMS": "3",  # the number of forms rendered
+            "form-INITIAL_FORMS": "0",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-name": "Walt Whitman",
+            "form-1-name": "Charles Baudelaire",
+            "form-2-name": "",
+        }
+
+        qs = Poet.objects.all()
+        formset = PoetFormSet(data=data, queryset=qs)
+        self.assertTrue(formset.is_valid())
+
+        poets = formset.save()
+        self.assertEqual(len(poets), 2)
+        poet1, poet2 = poets
+        self.assertEqual(poet1.name, "Vladimir Mayakovsky")
+        self.assertEqual(poet2.name, "Vladimir Mayakovsky")
+
+    def test_custom_form(self):
+        """
+        model_formset_factory() respects fields and exclude parameters of a
+        custom form.
+        """
+
+        class PostForm1(forms.ModelForm):
+            class Meta:
+                model = Post
+                fields = ("title", "posted")
+
+        class PostForm2(forms.ModelForm):
+            class Meta:
+                model = Post
+                exclude = ("subtitle",)
+
+        PostFormSet = modelformset_factory(Post, form=PostForm1)
+        formset = PostFormSet()
+        self.assertNotIn("subtitle", formset.forms[0].fields)
+
+        PostFormSet = modelformset_factory(Post, form=PostForm2)
+        formset = PostFormSet()
+        self.assertNotIn("subtitle", formset.forms[0].fields)
+
+    def test_custom_queryset_init(self):
+        """
+        A queryset can be overridden in the formset's __init__() method.
+        """
+        Author.objects.create(name="Charles Baudelaire")
+        Author.objects.create(name="Paul Verlaine")
+
+        class BaseAuthorFormSet(BaseModelFormSet):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.queryset = Author.objects.filter(name__startswith="Charles")
+
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", formset=BaseAuthorFormSet
+        )
+        formset = AuthorFormSet()
+        self.assertEqual(len(formset.get_queryset()), 1)
+
+    def test_model_inheritance(self):
+        BetterAuthorFormSet = modelformset_factory(BetterAuthor, fields="__all__")
+        formset = BetterAuthorFormSet()
+        self.assertEqual(len(formset.forms), 1)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_form-0-name">Name:</label>'
+            '<input id="id_form-0-name" type="text" name="form-0-name" maxlength="100">'
+            '</p><p><label for="id_form-0-write_speed">Write speed:</label>'
+            '<input type="number" name="form-0-write_speed" id="id_form-0-write_speed">'
+            '<input type="hidden" name="form-0-author_ptr" id="id_form-0-author_ptr">'
+            "</p>",
+        )
+
+        data = {
+            "form-TOTAL_FORMS": "1",  # the number of forms rendered
+            "form-INITIAL_FORMS": "0",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-author_ptr": "",
+            "form-0-name": "Ernest Hemingway",
+            "form-0-write_speed": "10",
+        }
+
+        formset = BetterAuthorFormSet(data)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (author1,) = saved
+        self.assertEqual(author1, BetterAuthor.objects.get(name="Ernest Hemingway"))
+        hemingway_id = BetterAuthor.objects.get(name="Ernest Hemingway").pk
+
+        formset = BetterAuthorFormSet()
+        self.assertEqual(len(formset.forms), 2)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_form-0-name">Name:</label>'
+            '<input id="id_form-0-name" type="text" name="form-0-name" '
+            'value="Ernest Hemingway" maxlength="100"></p>'
+            '<p><label for="id_form-0-write_speed">Write speed:</label>'
+            '<input type="number" name="form-0-write_speed" value="10" '
+            'id="id_form-0-write_speed">'
+            '<input type="hidden" name="form-0-author_ptr" value="%d" '
+            'id="id_form-0-author_ptr"></p>' % hemingway_id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_form-1-name">Name:</label>'
+            '<input id="id_form-1-name" type="text" name="form-1-name" maxlength="100">'
+            '</p><p><label for="id_form-1-write_speed">Write speed:</label>'
+            '<input type="number" name="form-1-write_speed" id="id_form-1-write_speed">'
+            '<input type="hidden" name="form-1-author_ptr" id="id_form-1-author_ptr">'
+            "</p>",
+        )
+
+        data = {
+            "form-TOTAL_FORMS": "2",  # the number of forms rendered
+            "form-INITIAL_FORMS": "1",  # the number of forms with initial data
+            "form-MAX_NUM_FORMS": "",  # the max number of forms
+            "form-0-author_ptr": hemingway_id,
+            "form-0-name": "Ernest Hemingway",
+            "form-0-write_speed": "10",
+            "form-1-author_ptr": "",
+            "form-1-name": "",
+            "form-1-write_speed": "",
+        }
+
+        formset = BetterAuthorFormSet(data)
+        self.assertTrue(formset.is_valid())
+        self.assertEqual(formset.save(), [])
+
+    def test_inline_formsets(self):
+        # We can also create a formset that is tied to a parent model. This is
+        # how the admin system's edit inline functionality works.
+
+        AuthorBooksFormSet = inlineformset_factory(
+            Author, Book, can_delete=False, extra=3, fields="__all__"
+        )
+        author = Author.objects.create(name="Charles Baudelaire")
+
+        formset = AuthorBooksFormSet(instance=author)
+        self.assertEqual(len(formset.forms), 3)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_book_set-0-title">Title:</label>'
+            '<input id="id_book_set-0-title" type="text" name="book_set-0-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-0-author" value="%d" '
+            'id="id_book_set-0-author">'
+            '<input type="hidden" name="book_set-0-id" id="id_book_set-0-id">'
+            "</p>" % author.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_book_set-1-title">Title:</label>'
+            '<input id="id_book_set-1-title" type="text" name="book_set-1-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-1-author" value="%d" '
+            'id="id_book_set-1-author">'
+            '<input type="hidden" name="book_set-1-id" id="id_book_set-1-id"></p>'
+            % author.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_book_set-2-title">Title:</label>'
+            '<input id="id_book_set-2-title" type="text" name="book_set-2-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-2-author" value="%d" '
+            'id="id_book_set-2-author">'
+            '<input type="hidden" name="book_set-2-id" id="id_book_set-2-id"></p>'
+            % author.id,
+        )
+
+        data = {
+            "book_set-TOTAL_FORMS": "3",  # the number of forms rendered
+            "book_set-INITIAL_FORMS": "0",  # the number of forms with initial data
+            "book_set-MAX_NUM_FORMS": "",  # the max number of forms
+            "book_set-0-title": "Les Fleurs du Mal",
+            "book_set-1-title": "",
+            "book_set-2-title": "",
+        }
+
+        formset = AuthorBooksFormSet(data, instance=author)
+        self.assertTrue(formset.is_valid())
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (book1,) = saved
+        self.assertEqual(book1, Book.objects.get(title="Les Fleurs du Mal"))
+        self.assertSequenceEqual(author.book_set.all(), [book1])
+
+        # Now that we've added a book to Charles Baudelaire, let's try adding
+        # another one. This time though, an edit form will be available for
+        # every existing book.
+
+        AuthorBooksFormSet = inlineformset_factory(
+            Author, Book, can_delete=False, extra=2, fields="__all__"
+        )
+        author = Author.objects.get(name="Charles Baudelaire")
+
+        formset = AuthorBooksFormSet(instance=author)
+        self.assertEqual(len(formset.forms), 3)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_book_set-0-title">Title:</label>'
+            '<input id="id_book_set-0-title" type="text" name="book_set-0-title" '
+            'value="Les Fleurs du Mal" maxlength="100">'
+            '<input type="hidden" name="book_set-0-author" value="%d" '
+            'id="id_book_set-0-author">'
+            '<input type="hidden" name="book_set-0-id" value="%d" '
+            'id="id_book_set-0-id"></p>'
+            % (
+                author.id,
+                book1.id,
+            ),
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_book_set-1-title">Title:</label>'
+            '<input id="id_book_set-1-title" type="text" name="book_set-1-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-1-author" value="%d" '
+            'id="id_book_set-1-author">'
+            '<input type="hidden" name="book_set-1-id" id="id_book_set-1-id"></p>'
+            % author.id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_book_set-2-title">Title:</label>'
+            '<input id="id_book_set-2-title" type="text" name="book_set-2-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-2-author" value="%d" '
+            'id="id_book_set-2-author">'
+            '<input type="hidden" name="book_set-2-id" id="id_book_set-2-id"></p>'
+            % author.id,
+        )
+
+        data = {
+            "book_set-TOTAL_FORMS": "3",  # the number of forms rendered
+            "book_set-INITIAL_FORMS": "1",  # the number of forms with initial data
+            "book_set-MAX_NUM_FORMS": "",  # the max number of forms
+            "book_set-0-id": str(book1.id),
+            "book_set-0-title": "Les Fleurs du Mal",
+            "book_set-1-title": "Les Paradis Artificiels",
+            "book_set-2-title": "",
+        }
+
+        formset = AuthorBooksFormSet(data, instance=author)
+        self.assertTrue(formset.is_valid())
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (book2,) = saved
+        self.assertEqual(book2, Book.objects.get(title="Les Paradis Artificiels"))
+
+        # As you can see, 'Les Paradis Artificiels' is now a book belonging to
+        # Charles Baudelaire.
+        self.assertSequenceEqual(author.book_set.order_by("title"), [book1, book2])
+
+    def test_inline_formsets_save_as_new(self):
+        # The save_as_new parameter lets you re-associate the data to a new
+        # instance.  This is used in the admin for save_as functionality.
+        AuthorBooksFormSet = inlineformset_factory(
+            Author, Book, can_delete=False, extra=2, fields="__all__"
+        )
+        Author.objects.create(name="Charles Baudelaire")
+
+        # An immutable QueryDict simulates request.POST.
+        data = QueryDict(mutable=True)
+        data.update(
+            {
+                "book_set-TOTAL_FORMS": "3",  # the number of forms rendered
+                "book_set-INITIAL_FORMS": "2",  # the number of forms with initial data
+                "book_set-MAX_NUM_FORMS": "",  # the max number of forms
+                "book_set-0-id": "1",
+                "book_set-0-title": "Les Fleurs du Mal",
+                "book_set-1-id": "2",
+                "book_set-1-title": "Les Paradis Artificiels",
+                "book_set-2-title": "",
+            }
+        )
+        data._mutable = False
+
+        formset = AuthorBooksFormSet(data, instance=Author(), save_as_new=True)
+        self.assertTrue(formset.is_valid())
+        self.assertIs(data._mutable, False)
+
+        new_author = Author.objects.create(name="Charles Baudelaire")
+        formset = AuthorBooksFormSet(data, instance=new_author, save_as_new=True)
+        saved = formset.save()
+        self.assertEqual(len(saved), 2)
+        book1, book2 = saved
+        self.assertEqual(book1.title, "Les Fleurs du Mal")
+        self.assertEqual(book2.title, "Les Paradis Artificiels")
+
+        # Test using a custom prefix on an inline formset.
+
+        formset = AuthorBooksFormSet(prefix="test")
+        self.assertEqual(len(formset.forms), 2)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_test-0-title">Title:</label>'
+            '<input id="id_test-0-title" type="text" name="test-0-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="test-0-author" id="id_test-0-author">'
+            '<input type="hidden" name="test-0-id" id="id_test-0-id"></p>',
+        )
+
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_test-1-title">Title:</label>'
+            '<input id="id_test-1-title" type="text" name="test-1-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="test-1-author" id="id_test-1-author">'
+            '<input type="hidden" name="test-1-id" id="id_test-1-id"></p>',
+        )
+
+    def test_inline_formsets_with_custom_pk(self):
+        # Test inline formsets where the inline-edited object has a custom
+        # primary key that is not the fk to the parent object.
+        self.maxDiff = 1024
+
+        AuthorBooksFormSet2 = inlineformset_factory(
+            Author, BookWithCustomPK, can_delete=False, extra=1, fields="__all__"
+        )
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+
+        formset = AuthorBooksFormSet2(instance=author)
+        self.assertEqual(len(formset.forms), 1)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_bookwithcustompk_set-0-my_pk">My pk:</label>'
+            '<input id="id_bookwithcustompk_set-0-my_pk" type="number" '
+            'name="bookwithcustompk_set-0-my_pk" step="1"></p>'
+            '<p><label for="id_bookwithcustompk_set-0-title">Title:</label>'
+            '<input id="id_bookwithcustompk_set-0-title" type="text" '
+            'name="bookwithcustompk_set-0-title" maxlength="100">'
+            '<input type="hidden" name="bookwithcustompk_set-0-author" '
+            'value="1" id="id_bookwithcustompk_set-0-author"></p>',
+        )
+
+        data = {
+            # The number of forms rendered.
+            "bookwithcustompk_set-TOTAL_FORMS": "1",
+            # The number of forms with initial data.
+            "bookwithcustompk_set-INITIAL_FORMS": "0",
+            # The max number of forms.
+            "bookwithcustompk_set-MAX_NUM_FORMS": "",
+            "bookwithcustompk_set-0-my_pk": "77777",
+            "bookwithcustompk_set-0-title": "Les Fleurs du Mal",
+        }
+
+        formset = AuthorBooksFormSet2(data, instance=author)
+        self.assertTrue(formset.is_valid())
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (book1,) = saved
+        self.assertEqual(book1.pk, 77777)
+
+        book1 = author.bookwithcustompk_set.get()
+        self.assertEqual(book1.title, "Les Fleurs du Mal")
+
+    def test_inline_formsets_with_multi_table_inheritance(self):
+        # Test inline formsets where the inline-edited object uses multi-table
+        # inheritance, thus has a non AutoField yet auto-created primary key.
+
+        AuthorBooksFormSet3 = inlineformset_factory(
+            Author, AlternateBook, can_delete=False, extra=1, fields="__all__"
+        )
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+
+        formset = AuthorBooksFormSet3(instance=author)
+        self.assertEqual(len(formset.forms), 1)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_alternatebook_set-0-title">Title:</label>'
+            '<input id="id_alternatebook_set-0-title" type="text" '
+            'name="alternatebook_set-0-title" maxlength="100"></p>'
+            '<p><label for="id_alternatebook_set-0-notes">Notes:</label>'
+            '<input id="id_alternatebook_set-0-notes" type="text" '
+            'name="alternatebook_set-0-notes" maxlength="100">'
+            '<input type="hidden" name="alternatebook_set-0-author" value="1" '
+            'id="id_alternatebook_set-0-author">'
+            '<input type="hidden" name="alternatebook_set-0-book_ptr" '
+            'id="id_alternatebook_set-0-book_ptr"></p>',
+        )
+
+        data = {
+            # The number of forms rendered.
+            "alternatebook_set-TOTAL_FORMS": "1",
+            # The number of forms with initial data.
+            "alternatebook_set-INITIAL_FORMS": "0",
+            # The max number of forms.
+            "alternatebook_set-MAX_NUM_FORMS": "",
+            "alternatebook_set-0-title": "Flowers of Evil",
+            "alternatebook_set-0-notes": "English translation of Les Fleurs du Mal",
+        }
+
+        formset = AuthorBooksFormSet3(data, instance=author)
+        self.assertTrue(formset.is_valid())
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (book1,) = saved
+        self.assertEqual(book1.title, "Flowers of Evil")
+        self.assertEqual(book1.notes, "English translation of Les Fleurs du Mal")
+
+    @skipUnlessDBFeature("supports_partially_nullable_unique_constraints")
+    def test_inline_formsets_with_nullable_unique_together(self):
+        # Test inline formsets where the inline-edited object has a
+        # unique_together constraint with a nullable member
+
+        AuthorBooksFormSet4 = inlineformset_factory(
+            Author,
+            BookWithOptionalAltEditor,
+            can_delete=False,
+            extra=2,
+            fields="__all__",
+        )
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+
+        data = {
+            # The number of forms rendered.
+            "bookwithoptionalalteditor_set-TOTAL_FORMS": "2",
+            # The number of forms with initial data.
+            "bookwithoptionalalteditor_set-INITIAL_FORMS": "0",
+            # The max number of forms.
+            "bookwithoptionalalteditor_set-MAX_NUM_FORMS": "",
+            "bookwithoptionalalteditor_set-0-author": "1",
+            "bookwithoptionalalteditor_set-0-title": "Les Fleurs du Mal",
+            "bookwithoptionalalteditor_set-1-author": "1",
+            "bookwithoptionalalteditor_set-1-title": "Les Fleurs du Mal",
+        }
+        formset = AuthorBooksFormSet4(data, instance=author)
+        self.assertTrue(formset.is_valid())
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 2)
+        book1, book2 = saved
+        self.assertEqual(book1.author_id, 1)
+        self.assertEqual(book1.title, "Les Fleurs du Mal")
+        self.assertEqual(book2.author_id, 1)
+        self.assertEqual(book2.title, "Les Fleurs du Mal")
+
+    def test_inline_formsets_with_custom_save_method(self):
+        AuthorBooksFormSet = inlineformset_factory(
+            Author, Book, can_delete=False, extra=2, fields="__all__"
+        )
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+        book1 = Book.objects.create(
+            pk=1, author=author, title="Les Paradis Artificiels"
+        )
+        book2 = Book.objects.create(pk=2, author=author, title="Les Fleurs du Mal")
+        book3 = Book.objects.create(pk=3, author=author, title="Flowers of Evil")
+
+        class PoemForm(forms.ModelForm):
+            def save(self, commit=True):
+                # change the name to "Brooklyn Bridge" just to be a jerk.
+                poem = super().save(commit=False)
+                poem.name = "Brooklyn Bridge"
+                if commit:
+                    poem.save()
+                return poem
+
+        PoemFormSet = inlineformset_factory(Poet, Poem, form=PoemForm, fields="__all__")
+
+        data = {
+            "poem_set-TOTAL_FORMS": "3",  # the number of forms rendered
+            "poem_set-INITIAL_FORMS": "0",  # the number of forms with initial data
+            "poem_set-MAX_NUM_FORMS": "",  # the max number of forms
+            "poem_set-0-name": "The Cloud in Trousers",
+            "poem_set-1-name": "I",
+            "poem_set-2-name": "",
+        }
+
+        poet = Poet.objects.create(name="Vladimir Mayakovsky")
+        formset = PoemFormSet(data=data, instance=poet)
+        self.assertTrue(formset.is_valid())
+
+        saved = formset.save()
+        self.assertEqual(len(saved), 2)
+        poem1, poem2 = saved
+        self.assertEqual(poem1.name, "Brooklyn Bridge")
+        self.assertEqual(poem2.name, "Brooklyn Bridge")
+
+        # We can provide a custom queryset to our InlineFormSet:
+
+        custom_qs = Book.objects.order_by("-title")
+        formset = AuthorBooksFormSet(instance=author, queryset=custom_qs)
+        self.assertEqual(len(formset.forms), 5)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_book_set-0-title">Title:</label>'
+            '<input id="id_book_set-0-title" type="text" name="book_set-0-title" '
+            'value="Les Paradis Artificiels" maxlength="100">'
+            '<input type="hidden" name="book_set-0-author" value="1" '
+            'id="id_book_set-0-author">'
+            '<input type="hidden" name="book_set-0-id" value="1" id="id_book_set-0-id">'
+            "</p>",
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_book_set-1-title">Title:</label>'
+            '<input id="id_book_set-1-title" type="text" name="book_set-1-title" '
+            'value="Les Fleurs du Mal" maxlength="100">'
+            '<input type="hidden" name="book_set-1-author" value="1" '
+            'id="id_book_set-1-author">'
+            '<input type="hidden" name="book_set-1-id" value="2" id="id_book_set-1-id">'
+            "</p>",
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_book_set-2-title">Title:</label>'
+            '<input id="id_book_set-2-title" type="text" name="book_set-2-title" '
+            'value="Flowers of Evil" maxlength="100">'
+            '<input type="hidden" name="book_set-2-author" value="1" '
+            'id="id_book_set-2-author">'
+            '<input type="hidden" name="book_set-2-id" value="3" '
+            'id="id_book_set-2-id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[3].as_p(),
+            '<p><label for="id_book_set-3-title">Title:</label>'
+            '<input id="id_book_set-3-title" type="text" name="book_set-3-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-3-author" value="1" '
+            'id="id_book_set-3-author">'
+            '<input type="hidden" name="book_set-3-id" id="id_book_set-3-id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[4].as_p(),
+            '<p><label for="id_book_set-4-title">Title:</label>'
+            '<input id="id_book_set-4-title" type="text" name="book_set-4-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-4-author" value="1" '
+            'id="id_book_set-4-author">'
+            '<input type="hidden" name="book_set-4-id" id="id_book_set-4-id"></p>',
+        )
+
+        data = {
+            "book_set-TOTAL_FORMS": "5",  # the number of forms rendered
+            "book_set-INITIAL_FORMS": "3",  # the number of forms with initial data
+            "book_set-MAX_NUM_FORMS": "",  # the max number of forms
+            "book_set-0-id": str(book1.id),
+            "book_set-0-title": "Les Paradis Artificiels",
+            "book_set-1-id": str(book2.id),
+            "book_set-1-title": "Les Fleurs du Mal",
+            "book_set-2-id": str(book3.id),
+            "book_set-2-title": "Flowers of Evil",
+            "book_set-3-title": "Revue des deux mondes",
+            "book_set-4-title": "",
+        }
+        formset = AuthorBooksFormSet(data, instance=author, queryset=custom_qs)
+        self.assertTrue(formset.is_valid())
+
+        custom_qs = Book.objects.filter(title__startswith="F")
+        formset = AuthorBooksFormSet(instance=author, queryset=custom_qs)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_book_set-0-title">Title:</label>'
+            '<input id="id_book_set-0-title" type="text" name="book_set-0-title" '
+            'value="Flowers of Evil" maxlength="100">'
+            '<input type="hidden" name="book_set-0-author" value="1" '
+            'id="id_book_set-0-author">'
+            '<input type="hidden" name="book_set-0-id" value="3" '
+            'id="id_book_set-0-id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_book_set-1-title">Title:</label>'
+            '<input id="id_book_set-1-title" type="text" name="book_set-1-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-1-author" value="1" '
+            'id="id_book_set-1-author">'
+            '<input type="hidden" name="book_set-1-id" id="id_book_set-1-id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_book_set-2-title">Title:</label>'
+            '<input id="id_book_set-2-title" type="text" name="book_set-2-title" '
+            'maxlength="100">'
+            '<input type="hidden" name="book_set-2-author" value="1" '
+            'id="id_book_set-2-author">'
+            '<input type="hidden" name="book_set-2-id" id="id_book_set-2-id"></p>',
+        )
+
+        data = {
+            "book_set-TOTAL_FORMS": "3",  # the number of forms rendered
+            "book_set-INITIAL_FORMS": "1",  # the number of forms with initial data
+            "book_set-MAX_NUM_FORMS": "",  # the max number of forms
+            "book_set-0-id": str(book3.id),
+            "book_set-0-title": "Flowers of Evil",
+            "book_set-1-title": "Revue des deux mondes",
+            "book_set-2-title": "",
+        }
+        formset = AuthorBooksFormSet(data, instance=author, queryset=custom_qs)
+        self.assertTrue(formset.is_valid())
+
+    def test_inline_formsets_with_custom_save_method_related_instance(self):
+        """
+        The ModelForm.save() method should be able to access the related object
+        if it exists in the database (#24395).
+        """
+
+        class PoemForm2(forms.ModelForm):
+            def save(self, commit=True):
+                poem = super().save(commit=False)
+                poem.name = "%s by %s" % (poem.name, poem.poet.name)
+                if commit:
+                    poem.save()
+                return poem
+
+        PoemFormSet = inlineformset_factory(
+            Poet, Poem, form=PoemForm2, fields="__all__"
+        )
+        data = {
+            "poem_set-TOTAL_FORMS": "1",
+            "poem_set-INITIAL_FORMS": "0",
+            "poem_set-MAX_NUM_FORMS": "",
+            "poem_set-0-name": "Le Lac",
+        }
+        poet = Poet()
+        formset = PoemFormSet(data=data, instance=poet)
+        self.assertTrue(formset.is_valid())
+
+        # The Poet instance is saved after the formset instantiation. This
+        # happens in admin's changeform_view() when adding a new object and
+        # some inlines in the same request.
+        poet.name = "Lamartine"
+        poet.save()
+        poem = formset.save()[0]
+        self.assertEqual(poem.name, "Le Lac by Lamartine")
+
+    def test_inline_formsets_with_wrong_fk_name(self):
+        """Regression for #23451"""
+        message = "fk_name 'title' is not a ForeignKey to 'model_formsets.Author'."
+        with self.assertRaisesMessage(ValueError, message):
+            inlineformset_factory(Author, Book, fields="__all__", fk_name="title")
+
+    def test_custom_pk(self):
+        # We need to ensure that it is displayed
+
+        CustomPrimaryKeyFormSet = modelformset_factory(
+            CustomPrimaryKey, fields="__all__"
+        )
+        formset = CustomPrimaryKeyFormSet()
+        self.assertEqual(len(formset.forms), 1)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_form-0-my_pk">My pk:</label>'
+            '<input id="id_form-0-my_pk" type="text" name="form-0-my_pk" '
+            'maxlength="10"></p>'
+            '<p><label for="id_form-0-some_field">Some field:</label>'
+            '<input id="id_form-0-some_field" type="text" name="form-0-some_field" '
+            'maxlength="100"></p>',
+        )
+
+        # Custom primary keys with ForeignKey, OneToOneField and AutoField ############
+
+        place = Place.objects.create(pk=1, name="Giordanos", city="Chicago")
+
+        FormSet = inlineformset_factory(
+            Place, Owner, extra=2, can_delete=False, fields="__all__"
+        )
+        formset = FormSet(instance=place)
+        self.assertEqual(len(formset.forms), 2)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_owner_set-0-name">Name:</label>'
+            '<input id="id_owner_set-0-name" type="text" name="owner_set-0-name" '
+            'maxlength="100">'
+            '<input type="hidden" name="owner_set-0-place" value="1" '
+            'id="id_owner_set-0-place">'
+            '<input type="hidden" name="owner_set-0-auto_id" '
+            'id="id_owner_set-0-auto_id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_owner_set-1-name">Name:</label>'
+            '<input id="id_owner_set-1-name" type="text" name="owner_set-1-name" '
+            'maxlength="100">'
+            '<input type="hidden" name="owner_set-1-place" value="1" '
+            'id="id_owner_set-1-place">'
+            '<input type="hidden" name="owner_set-1-auto_id" '
+            'id="id_owner_set-1-auto_id"></p>',
+        )
+
+        data = {
+            "owner_set-TOTAL_FORMS": "2",
+            "owner_set-INITIAL_FORMS": "0",
+            "owner_set-MAX_NUM_FORMS": "",
+            "owner_set-0-auto_id": "",
+            "owner_set-0-name": "Joe Perry",
+            "owner_set-1-auto_id": "",
+            "owner_set-1-name": "",
+        }
+        formset = FormSet(data, instance=place)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (owner1,) = saved
+        self.assertEqual(owner1.name, "Joe Perry")
+        self.assertEqual(owner1.place.name, "Giordanos")
+
+        formset = FormSet(instance=place)
+        self.assertEqual(len(formset.forms), 3)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_owner_set-0-name">Name:</label>'
+            '<input id="id_owner_set-0-name" type="text" name="owner_set-0-name" '
+            'value="Joe Perry" maxlength="100">'
+            '<input type="hidden" name="owner_set-0-place" value="1" '
+            'id="id_owner_set-0-place">'
+            '<input type="hidden" name="owner_set-0-auto_id" value="%d" '
+            'id="id_owner_set-0-auto_id"></p>' % owner1.auto_id,
+        )
+        self.assertHTMLEqual(
+            formset.forms[1].as_p(),
+            '<p><label for="id_owner_set-1-name">Name:</label>'
+            '<input id="id_owner_set-1-name" type="text" name="owner_set-1-name" '
+            'maxlength="100">'
+            '<input type="hidden" name="owner_set-1-place" value="1" '
+            'id="id_owner_set-1-place">'
+            '<input type="hidden" name="owner_set-1-auto_id" '
+            'id="id_owner_set-1-auto_id"></p>',
+        )
+        self.assertHTMLEqual(
+            formset.forms[2].as_p(),
+            '<p><label for="id_owner_set-2-name">Name:</label>'
+            '<input id="id_owner_set-2-name" type="text" name="owner_set-2-name" '
+            'maxlength="100">'
+            '<input type="hidden" name="owner_set-2-place" value="1" '
+            'id="id_owner_set-2-place">'
+            '<input type="hidden" name="owner_set-2-auto_id" '
+            'id="id_owner_set-2-auto_id"></p>',
+        )
+
+        data = {
+            "owner_set-TOTAL_FORMS": "3",
+            "owner_set-INITIAL_FORMS": "1",
+            "owner_set-MAX_NUM_FORMS": "",
+            "owner_set-0-auto_id": str(owner1.auto_id),
+            "owner_set-0-name": "Joe Perry",
+            "owner_set-1-auto_id": "",
+            "owner_set-1-name": "Jack Berry",
+            "owner_set-2-auto_id": "",
+            "owner_set-2-name": "",
+        }
+        formset = FormSet(data, instance=place)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (owner2,) = saved
+        self.assertEqual(owner2.name, "Jack Berry")
+        self.assertEqual(owner2.place.name, "Giordanos")
+
+        # A custom primary key that is a ForeignKey or OneToOneField get
+        # rendered for the user to choose.
+        FormSet = modelformset_factory(OwnerProfile, fields="__all__")
+        formset = FormSet()
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_form-0-owner">Owner:</label>'
+            '<select name="form-0-owner" id="id_form-0-owner">'
+            '<option value="" selected>---------</option>'
+            '<option value="%d">Joe Perry at Giordanos</option>'
+            '<option value="%d">Jack Berry at Giordanos</option>'
+            "</select></p>"
+            '<p><label for="id_form-0-age">Age:</label>'
+            '<input type="number" name="form-0-age" id="id_form-0-age" min="0"></p>'
+            % (owner1.auto_id, owner2.auto_id),
+        )
+
+        owner1 = Owner.objects.get(name="Joe Perry")
+        FormSet = inlineformset_factory(
+            Owner, OwnerProfile, max_num=1, can_delete=False, fields="__all__"
+        )
+        self.assertEqual(FormSet.max_num, 1)
+
+        formset = FormSet(instance=owner1)
+        self.assertEqual(len(formset.forms), 1)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_ownerprofile-0-age">Age:</label>'
+            '<input type="number" name="ownerprofile-0-age" '
+            'id="id_ownerprofile-0-age" min="0">'
+            '<input type="hidden" name="ownerprofile-0-owner" value="%d" '
+            'id="id_ownerprofile-0-owner"></p>' % owner1.auto_id,
+        )
+
+        data = {
+            "ownerprofile-TOTAL_FORMS": "1",
+            "ownerprofile-INITIAL_FORMS": "0",
+            "ownerprofile-MAX_NUM_FORMS": "1",
+            "ownerprofile-0-owner": "",
+            "ownerprofile-0-age": "54",
+        }
+        formset = FormSet(data, instance=owner1)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (profile1,) = saved
+        self.assertEqual(profile1.owner, owner1)
+        self.assertEqual(profile1.age, 54)
+
+        formset = FormSet(instance=owner1)
+        self.assertEqual(len(formset.forms), 1)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_ownerprofile-0-age">Age:</label>'
+            '<input type="number" name="ownerprofile-0-age" value="54" '
+            'id="id_ownerprofile-0-age" min="0">'
+            '<input type="hidden" name="ownerprofile-0-owner" value="%d" '
+            'id="id_ownerprofile-0-owner"></p>' % owner1.auto_id,
+        )
+
+        data = {
+            "ownerprofile-TOTAL_FORMS": "1",
+            "ownerprofile-INITIAL_FORMS": "1",
+            "ownerprofile-MAX_NUM_FORMS": "1",
+            "ownerprofile-0-owner": str(owner1.auto_id),
+            "ownerprofile-0-age": "55",
+        }
+        formset = FormSet(data, instance=owner1)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (profile1,) = saved
+        self.assertEqual(profile1.owner, owner1)
+        self.assertEqual(profile1.age, 55)
+
+    def test_unique_true_enforces_max_num_one(self):
+        # ForeignKey with unique=True should enforce max_num=1
+
+        place = Place.objects.create(pk=1, name="Giordanos", city="Chicago")
+
+        FormSet = inlineformset_factory(
+            Place, Location, can_delete=False, fields="__all__"
+        )
+        self.assertEqual(FormSet.max_num, 1)
+
+        formset = FormSet(instance=place)
+        self.assertEqual(len(formset.forms), 1)
+        self.assertHTMLEqual(
+            formset.forms[0].as_p(),
+            '<p><label for="id_location_set-0-lat">Lat:</label>'
+            '<input id="id_location_set-0-lat" type="text" name="location_set-0-lat" '
+            'maxlength="100"></p>'
+            '<p><label for="id_location_set-0-lon">Lon:</label>'
+            '<input id="id_location_set-0-lon" type="text" name="location_set-0-lon" '
+            'maxlength="100">'
+            '<input type="hidden" name="location_set-0-place" value="1" '
+            'id="id_location_set-0-place">'
+            '<input type="hidden" name="location_set-0-id" '
+            'id="id_location_set-0-id"></p>',
+        )
+
+    def test_foreign_keys_in_parents(self):
+        self.assertEqual(type(_get_foreign_key(Restaurant, Owner)), models.ForeignKey)
+        self.assertEqual(
+            type(_get_foreign_key(MexicanRestaurant, Owner)), models.ForeignKey
+        )
+
+    def test_unique_validation(self):
+        FormSet = modelformset_factory(Product, fields="__all__", extra=1)
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-slug": "car-red",
+        }
+        formset = FormSet(data)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (product1,) = saved
+        self.assertEqual(product1.slug, "car-red")
+
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-slug": "car-red",
+        }
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset.errors, [{"slug": ["Product with this Slug already exists."]}]
+        )
+
+    def test_modelformset_validate_max_flag(self):
+        # If validate_max is set and max_num is less than TOTAL_FORMS in the
+        # data, then throw an exception. MAX_NUM_FORMS in the data is
+        # irrelevant here (it's output as a hint for the client but its
+        # value in the returned data is not checked)
+
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "2",  # should be ignored
+            "form-0-price": "12.00",
+            "form-0-quantity": "1",
+            "form-1-price": "24.00",
+            "form-1-quantity": "2",
+        }
+
+        FormSet = modelformset_factory(
+            Price, fields="__all__", extra=1, max_num=1, validate_max=True
+        )
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(formset.non_form_errors(), ["Please submit at most 1 form."])
+
+        # Now test the same thing without the validate_max flag to ensure
+        # default behavior is unchanged
+        FormSet = modelformset_factory(Price, fields="__all__", extra=1, max_num=1)
+        formset = FormSet(data)
+        self.assertTrue(formset.is_valid())
+
+    def test_modelformset_min_num_equals_max_num_less_than(self):
+        data = {
+            "form-TOTAL_FORMS": "3",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "2",
+            "form-0-slug": "car-red",
+            "form-1-slug": "car-blue",
+            "form-2-slug": "car-black",
+        }
+        FormSet = modelformset_factory(
+            Product,
+            fields="__all__",
+            extra=1,
+            max_num=2,
+            validate_max=True,
+            min_num=2,
+            validate_min=True,
+        )
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(formset.non_form_errors(), ["Please submit at most 2 forms."])
+
+    def test_modelformset_min_num_equals_max_num_more_than(self):
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "2",
+            "form-0-slug": "car-red",
+        }
+        FormSet = modelformset_factory(
+            Product,
+            fields="__all__",
+            extra=1,
+            max_num=2,
+            validate_max=True,
+            min_num=2,
+            validate_min=True,
+        )
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(formset.non_form_errors(), ["Please submit at least 2 forms."])
+
+    def test_unique_together_validation(self):
+        FormSet = modelformset_factory(Price, fields="__all__", extra=1)
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-price": "12.00",
+            "form-0-quantity": "1",
+        }
+        formset = FormSet(data)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (price1,) = saved
+        self.assertEqual(price1.price, Decimal("12.00"))
+        self.assertEqual(price1.quantity, 1)
+
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-price": "12.00",
+            "form-0-quantity": "1",
+        }
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset.errors,
+            [{"__all__": ["Price with this Price and Quantity already exists."]}],
+        )
+
+    def test_unique_together_with_inlineformset_factory(self):
+        # Also see bug #8882.
+
+        repository = Repository.objects.create(name="Test Repo")
+        FormSet = inlineformset_factory(Repository, Revision, extra=1, fields="__all__")
+        data = {
+            "revision_set-TOTAL_FORMS": "1",
+            "revision_set-INITIAL_FORMS": "0",
+            "revision_set-MAX_NUM_FORMS": "",
+            "revision_set-0-repository": repository.pk,
+            "revision_set-0-revision": "146239817507f148d448db38840db7c3cbf47c76",
+            "revision_set-0-DELETE": "",
+        }
+        formset = FormSet(data, instance=repository)
+        self.assertTrue(formset.is_valid())
+        saved = formset.save()
+        self.assertEqual(len(saved), 1)
+        (revision1,) = saved
+        self.assertEqual(revision1.repository, repository)
+        self.assertEqual(revision1.revision, "146239817507f148d448db38840db7c3cbf47c76")
+
+        # attempt to save the same revision against the same repo.
+        data = {
+            "revision_set-TOTAL_FORMS": "1",
+            "revision_set-INITIAL_FORMS": "0",
+            "revision_set-MAX_NUM_FORMS": "",
+            "revision_set-0-repository": repository.pk,
+            "revision_set-0-revision": "146239817507f148d448db38840db7c3cbf47c76",
+            "revision_set-0-DELETE": "",
+        }
+        formset = FormSet(data, instance=repository)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset.errors,
+            [
+                {
+                    "__all__": [
+                        "Revision with this Repository and Revision already exists."
+                    ]
+                }
+            ],
+        )
+
+        # unique_together with inlineformset_factory with overridden form fields
+        # Also see #9494
+
+        FormSet = inlineformset_factory(
+            Repository, Revision, fields=("revision",), extra=1
+        )
+        data = {
+            "revision_set-TOTAL_FORMS": "1",
+            "revision_set-INITIAL_FORMS": "0",
+            "revision_set-MAX_NUM_FORMS": "",
+            "revision_set-0-repository": repository.pk,
+            "revision_set-0-revision": "146239817507f148d448db38840db7c3cbf47c76",
+            "revision_set-0-DELETE": "",
+        }
+        formset = FormSet(data, instance=repository)
+        self.assertFalse(formset.is_valid())
+
+    def test_callable_defaults(self):
+        # Use of callable defaults (see bug #7975).
+
+        person = Person.objects.create(name="Ringo")
+        FormSet = inlineformset_factory(
+            Person, Membership, can_delete=False, extra=1, fields="__all__"
+        )
+        formset = FormSet(instance=person)
+
+        # Django will render a hidden field for model fields that have a callable
+        # default. This is required to ensure the value is tested for change correctly
+        # when determine what extra forms have changed to save.
+
+        self.assertEqual(len(formset.forms), 1)  # this formset only has one form
+        form = formset.forms[0]
+        now = form.fields["date_joined"].initial()
+        result = form.as_p()
+        result = re.sub(
+            r"[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?",
+            "__DATETIME__",
+            result,
+        )
+        self.assertHTMLEqual(
+            result,
+            '<p><label for="id_membership_set-0-date_joined">Date joined:</label>'
+            '<input type="text" name="membership_set-0-date_joined" '
+            'value="__DATETIME__" id="id_membership_set-0-date_joined">'
+            '<input type="hidden" name="initial-membership_set-0-date_joined" '
+            'value="__DATETIME__" '
+            'id="initial-membership_set-0-id_membership_set-0-date_joined"></p>'
+            '<p><label for="id_membership_set-0-karma">Karma:</label>'
+            '<input type="number" name="membership_set-0-karma" '
+            'id="id_membership_set-0-karma">'
+            '<input type="hidden" name="membership_set-0-person" value="%d" '
+            'id="id_membership_set-0-person">'
+            '<input type="hidden" name="membership_set-0-id" '
+            'id="id_membership_set-0-id"></p>' % person.id,
+        )
+
+        # test for validation with callable defaults. Validations rely on hidden fields
+
+        data = {
+            "membership_set-TOTAL_FORMS": "1",
+            "membership_set-INITIAL_FORMS": "0",
+            "membership_set-MAX_NUM_FORMS": "",
+            "membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"),
+            "initial-membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"),
+            "membership_set-0-karma": "",
+        }
+        formset = FormSet(data, instance=person)
+        self.assertTrue(formset.is_valid())
+
+        # now test for when the data changes
+
+        one_day_later = now + datetime.timedelta(days=1)
+        filled_data = {
+            "membership_set-TOTAL_FORMS": "1",
+            "membership_set-INITIAL_FORMS": "0",
+            "membership_set-MAX_NUM_FORMS": "",
+            "membership_set-0-date_joined": one_day_later.strftime("%Y-%m-%d %H:%M:%S"),
+            "initial-membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"),
+            "membership_set-0-karma": "",
+        }
+        formset = FormSet(filled_data, instance=person)
+        self.assertFalse(formset.is_valid())
+
+        # now test with split datetime fields
+
+        class MembershipForm(forms.ModelForm):
+            date_joined = forms.SplitDateTimeField(initial=now)
+
+            class Meta:
+                model = Membership
+                fields = "__all__"
+
+            def __init__(self, **kwargs):
+                super().__init__(**kwargs)
+                self.fields["date_joined"].widget = forms.SplitDateTimeWidget()
+
+        FormSet = inlineformset_factory(
+            Person,
+            Membership,
+            form=MembershipForm,
+            can_delete=False,
+            extra=1,
+            fields="__all__",
+        )
+        data = {
+            "membership_set-TOTAL_FORMS": "1",
+            "membership_set-INITIAL_FORMS": "0",
+            "membership_set-MAX_NUM_FORMS": "",
+            "membership_set-0-date_joined_0": now.strftime("%Y-%m-%d"),
+            "membership_set-0-date_joined_1": now.strftime("%H:%M:%S"),
+            "initial-membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"),
+            "membership_set-0-karma": "",
+        }
+        formset = FormSet(data, instance=person)
+        self.assertTrue(formset.is_valid())
+
+    def test_inlineformset_factory_with_null_fk(self):
+        # inlineformset_factory tests with fk having null=True. see #9462.
+        # create some data that will exhibit the issue
+        team = Team.objects.create(name="Red Vipers")
+        Player(name="Timmy").save()
+        Player(name="Bobby", team=team).save()
+
+        PlayerInlineFormSet = inlineformset_factory(Team, Player, fields="__all__")
+        formset = PlayerInlineFormSet()
+        self.assertQuerySetEqual(formset.get_queryset(), [])
+
+        formset = PlayerInlineFormSet(instance=team)
+        players = formset.get_queryset()
+        self.assertEqual(len(players), 1)
+        (player1,) = players
+        self.assertEqual(player1.team, team)
+        self.assertEqual(player1.name, "Bobby")
+
+    def test_inlineformset_with_arrayfield(self):
+        class SimpleArrayField(forms.CharField):
+            """A proxy for django.contrib.postgres.forms.SimpleArrayField."""
+
+            def to_python(self, value):
+                value = super().to_python(value)
+                return value.split(",") if value else []
+
+        class BookForm(forms.ModelForm):
+            title = SimpleArrayField()
+
+            class Meta:
+                model = Book
+                fields = ("title",)
+
+        BookFormSet = inlineformset_factory(Author, Book, form=BookForm)
+        data = {
+            "book_set-TOTAL_FORMS": "3",
+            "book_set-INITIAL_FORMS": "0",
+            "book_set-MAX_NUM_FORMS": "",
+            "book_set-0-title": "test1,test2",
+            "book_set-1-title": "test1,test2",
+            "book_set-2-title": "test3,test4",
+        }
+        author = Author.objects.create(name="test")
+        formset = BookFormSet(data, instance=author)
+        self.assertEqual(
+            formset.errors,
+            [{}, {"__all__": ["Please correct the duplicate values below."]}, {}],
+        )
+
+    def test_model_formset_with_custom_pk(self):
+        # a formset for a Model that has a custom primary key that still needs to be
+        # added to the formset automatically
+        FormSet = modelformset_factory(
+            ClassyMexicanRestaurant, fields=["tacos_are_yummy"]
+        )
+        self.assertEqual(
+            sorted(FormSet().forms[0].fields), ["tacos_are_yummy", "the_restaurant"]
+        )
+
+    def test_model_formset_with_initial_model_instance(self):
+        # has_changed should compare model instance and primary key
+        # see #18898
+        FormSet = modelformset_factory(Poem, fields="__all__")
+        john_milton = Poet(name="John Milton")
+        john_milton.save()
+        data = {
+            "form-TOTAL_FORMS": 1,
+            "form-INITIAL_FORMS": 0,
+            "form-MAX_NUM_FORMS": "",
+            "form-0-name": "",
+            "form-0-poet": str(john_milton.id),
+        }
+        formset = FormSet(initial=[{"poet": john_milton}], data=data)
+        self.assertFalse(formset.extra_forms[0].has_changed())
+
+    def test_model_formset_with_initial_queryset(self):
+        # has_changed should work with queryset and list of pk's
+        # see #18898
+        FormSet = modelformset_factory(AuthorMeeting, fields="__all__")
+        Author.objects.create(pk=1, name="Charles Baudelaire")
+        data = {
+            "form-TOTAL_FORMS": 1,
+            "form-INITIAL_FORMS": 0,
+            "form-MAX_NUM_FORMS": "",
+            "form-0-name": "",
+            "form-0-created": "",
+            "form-0-authors": list(Author.objects.values_list("id", flat=True)),
+        }
+        formset = FormSet(initial=[{"authors": Author.objects.all()}], data=data)
+        self.assertFalse(formset.extra_forms[0].has_changed())
+
+    def test_prevent_duplicates_from_with_the_same_formset(self):
+        FormSet = modelformset_factory(Product, fields="__all__", extra=2)
+        data = {
+            "form-TOTAL_FORMS": 2,
+            "form-INITIAL_FORMS": 0,
+            "form-MAX_NUM_FORMS": "",
+            "form-0-slug": "red_car",
+            "form-1-slug": "red_car",
+        }
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset._non_form_errors, ["Please correct the duplicate data for slug."]
+        )
+
+        FormSet = modelformset_factory(Price, fields="__all__", extra=2)
+        data = {
+            "form-TOTAL_FORMS": 2,
+            "form-INITIAL_FORMS": 0,
+            "form-MAX_NUM_FORMS": "",
+            "form-0-price": "25",
+            "form-0-quantity": "7",
+            "form-1-price": "25",
+            "form-1-quantity": "7",
+        }
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset._non_form_errors,
+            [
+                "Please correct the duplicate data for price and quantity, which must "
+                "be unique."
+            ],
+        )
+
+        # Only the price field is specified, this should skip any unique
+        # checks since the unique_together is not fulfilled. This will fail
+        # with a KeyError if broken.
+        FormSet = modelformset_factory(Price, fields=("price",), extra=2)
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-price": "24",
+            "form-1-price": "24",
+        }
+        formset = FormSet(data)
+        self.assertTrue(formset.is_valid())
+
+        FormSet = inlineformset_factory(Author, Book, extra=0, fields="__all__")
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+        Book.objects.create(pk=1, author=author, title="Les Paradis Artificiels")
+        Book.objects.create(pk=2, author=author, title="Les Fleurs du Mal")
+        Book.objects.create(pk=3, author=author, title="Flowers of Evil")
+
+        book_ids = author.book_set.order_by("id").values_list("id", flat=True)
+        data = {
+            "book_set-TOTAL_FORMS": "2",
+            "book_set-INITIAL_FORMS": "2",
+            "book_set-MAX_NUM_FORMS": "",
+            "book_set-0-title": "The 2008 Election",
+            "book_set-0-author": str(author.id),
+            "book_set-0-id": str(book_ids[0]),
+            "book_set-1-title": "The 2008 Election",
+            "book_set-1-author": str(author.id),
+            "book_set-1-id": str(book_ids[1]),
+        }
+        formset = FormSet(data=data, instance=author)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset._non_form_errors, ["Please correct the duplicate data for title."]
+        )
+        self.assertEqual(
+            formset.errors,
+            [{}, {"__all__": ["Please correct the duplicate values below."]}],
+        )
+
+        FormSet = modelformset_factory(Post, fields="__all__", extra=2)
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-title": "blah",
+            "form-0-slug": "Morning",
+            "form-0-subtitle": "foo",
+            "form-0-posted": "2009-01-01",
+            "form-1-title": "blah",
+            "form-1-slug": "Morning in Prague",
+            "form-1-subtitle": "rawr",
+            "form-1-posted": "2009-01-01",
+        }
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset._non_form_errors,
+            [
+                "Please correct the duplicate data for title which must be unique for "
+                "the date in posted."
+            ],
+        )
+        self.assertEqual(
+            formset.errors,
+            [{}, {"__all__": ["Please correct the duplicate values below."]}],
+        )
+
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-title": "foo",
+            "form-0-slug": "Morning in Prague",
+            "form-0-subtitle": "foo",
+            "form-0-posted": "2009-01-01",
+            "form-1-title": "blah",
+            "form-1-slug": "Morning in Prague",
+            "form-1-subtitle": "rawr",
+            "form-1-posted": "2009-08-02",
+        }
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset._non_form_errors,
+            [
+                "Please correct the duplicate data for slug which must be unique for "
+                "the year in posted."
+            ],
+        )
+
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-title": "foo",
+            "form-0-slug": "Morning in Prague",
+            "form-0-subtitle": "rawr",
+            "form-0-posted": "2008-08-01",
+            "form-1-title": "blah",
+            "form-1-slug": "Prague",
+            "form-1-subtitle": "rawr",
+            "form-1-posted": "2009-08-02",
+        }
+        formset = FormSet(data)
+        self.assertFalse(formset.is_valid())
+        self.assertEqual(
+            formset._non_form_errors,
+            [
+                "Please correct the duplicate data for subtitle which must be unique "
+                "for the month in posted."
+            ],
+        )
+
+    def test_prevent_change_outer_model_and_create_invalid_data(self):
+        author = Author.objects.create(name="Charles")
+        other_author = Author.objects.create(name="Walt")
+        AuthorFormSet = modelformset_factory(Author, fields="__all__")
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "2",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-id": str(author.id),
+            "form-0-name": "Charles",
+            "form-1-id": str(other_author.id),  # A model not in the formset's queryset.
+            "form-1-name": "Changed name",
+        }
+        # This formset is only for Walt Whitman and shouldn't accept data for
+        # other_author.
+        formset = AuthorFormSet(
+            data=data, queryset=Author.objects.filter(id__in=(author.id,))
+        )
+        self.assertTrue(formset.is_valid())
+        formset.save()
+        # The name of other_author shouldn't be changed and new models aren't
+        # created.
+        self.assertSequenceEqual(Author.objects.all(), [author, other_author])
+
+    def test_validation_without_id(self):
+        AuthorFormSet = modelformset_factory(Author, fields="__all__")
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-name": "Charles",
+        }
+        formset = AuthorFormSet(data)
+        self.assertEqual(
+            formset.errors,
+            [{"id": ["This field is required."]}],
+        )
+
+    def test_validation_with_child_model_without_id(self):
+        BetterAuthorFormSet = modelformset_factory(BetterAuthor, fields="__all__")
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-name": "Charles",
+            "form-0-write_speed": "10",
+        }
+        formset = BetterAuthorFormSet(data)
+        self.assertEqual(
+            formset.errors,
+            [{"author_ptr": ["This field is required."]}],
+        )
+
+    def test_validation_with_invalid_id(self):
+        AuthorFormSet = modelformset_factory(Author, fields="__all__")
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-id": "abc",
+            "form-0-name": "Charles",
+        }
+        formset = AuthorFormSet(data)
+        self.assertEqual(
+            formset.errors,
+            [
+                {
+                    "id": [
+                        "Select a valid choice. That choice is not one of the "
+                        "available choices."
+                    ]
+                }
+            ],
+        )
+
+    def test_validation_with_nonexistent_id(self):
+        AuthorFormSet = modelformset_factory(Author, fields="__all__")
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "",
+            "form-0-id": "12345",
+            "form-0-name": "Charles",
+        }
+        formset = AuthorFormSet(data)
+        self.assertEqual(
+            formset.errors,
+            [
+                {
+                    "id": [
+                        "Select a valid choice. That choice is not one of the "
+                        "available choices."
+                    ]
+                }
+            ],
+        )
+
+    def test_initial_form_count_empty_data(self):
+        AuthorFormSet = modelformset_factory(Author, fields="__all__")
+        formset = AuthorFormSet({})
+        self.assertEqual(formset.initial_form_count(), 0)
+
+    def test_edit_only(self):
+        charles = Author.objects.create(name="Charles Baudelaire")
+        AuthorFormSet = modelformset_factory(Author, fields="__all__", edit_only=True)
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "0",
+            "form-0-name": "Arthur Rimbaud",
+            "form-1-name": "Walt Whitman",
+        }
+        formset = AuthorFormSet(data)
+        self.assertIs(formset.is_valid(), True)
+        formset.save()
+        self.assertSequenceEqual(Author.objects.all(), [charles])
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "0",
+            "form-0-id": charles.pk,
+            "form-0-name": "Arthur Rimbaud",
+            "form-1-name": "Walt Whitman",
+        }
+        formset = AuthorFormSet(data)
+        self.assertIs(formset.is_valid(), True)
+        formset.save()
+        charles.refresh_from_db()
+        self.assertEqual(charles.name, "Arthur Rimbaud")
+        self.assertSequenceEqual(Author.objects.all(), [charles])
+
+    def test_edit_only_inlineformset_factory(self):
+        charles = Author.objects.create(name="Charles Baudelaire")
+        book = Book.objects.create(author=charles, title="Les Paradis Artificiels")
+        AuthorFormSet = inlineformset_factory(
+            Author,
+            Book,
+            can_delete=False,
+            fields="__all__",
+            edit_only=True,
+        )
+        data = {
+            "book_set-TOTAL_FORMS": "4",
+            "book_set-INITIAL_FORMS": "1",
+            "book_set-MAX_NUM_FORMS": "0",
+            "book_set-0-id": book.pk,
+            "book_set-0-title": "Les Fleurs du Mal",
+            "book_set-0-author": charles.pk,
+            "book_set-1-title": "Flowers of Evil",
+            "book_set-1-author": charles.pk,
+        }
+        formset = AuthorFormSet(data, instance=charles)
+        self.assertIs(formset.is_valid(), True)
+        formset.save()
+        book.refresh_from_db()
+        self.assertEqual(book.title, "Les Fleurs du Mal")
+        self.assertSequenceEqual(Book.objects.all(), [book])
+
+    def test_edit_only_object_outside_of_queryset(self):
+        charles = Author.objects.create(name="Charles Baudelaire")
+        walt = Author.objects.create(name="Walt Whitman")
+        data = {
+            "form-TOTAL_FORMS": "1",
+            "form-INITIAL_FORMS": "1",
+            "form-0-id": walt.pk,
+            "form-0-name": "Parth Patil",
+        }
+        AuthorFormSet = modelformset_factory(Author, fields="__all__", edit_only=True)
+        formset = AuthorFormSet(data, queryset=Author.objects.filter(pk=charles.pk))
+        self.assertIs(formset.is_valid(), True)
+        formset.save()
+        self.assertCountEqual(Author.objects.all(), [charles, walt])
+
+    def test_edit_only_formset_factory_with_basemodelformset(self):
+        charles = Author.objects.create(name="Charles Baudelaire")
+
+        class AuthorForm(forms.ModelForm):
+            class Meta:
+                model = Author
+                fields = "__all__"
+
+        class BaseAuthorFormSet(BaseModelFormSet):
+            def __init__(self, *args, **kwargs):
+                self.model = Author
+                super().__init__(*args, **kwargs)
+
+        AuthorFormSet = formset_factory(AuthorForm, formset=BaseAuthorFormSet)
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "1",
+            "form-MAX_NUM_FORMS": "0",
+            "form-0-id": charles.pk,
+            "form-0-name": "Shawn Dong",
+            "form-1-name": "Walt Whitman",
+        }
+        formset = AuthorFormSet(data)
+        self.assertIs(formset.is_valid(), True)
+        formset.save()
+        self.assertEqual(Author.objects.count(), 2)
+        charles.refresh_from_db()
+        self.assertEqual(charles.name, "Shawn Dong")
+        self.assertEqual(Author.objects.count(), 2)
+
+
+class TestModelFormsetOverridesTroughFormMeta(TestCase):
+    def test_modelformset_factory_widgets(self):
+        widgets = {"name": forms.TextInput(attrs={"class": "poet"})}
+        PoetFormSet = modelformset_factory(Poet, fields="__all__", widgets=widgets)
+        form = PoetFormSet.form()
+        self.assertHTMLEqual(
+            str(form["name"]),
+            '<input id="id_name" maxlength="100" type="text" class="poet" name="name" '
+            "required>",
+        )
+
+    def test_inlineformset_factory_widgets(self):
+        widgets = {"title": forms.TextInput(attrs={"class": "book"})}
+        BookFormSet = inlineformset_factory(
+            Author, Book, widgets=widgets, fields="__all__"
+        )
+        form = BookFormSet.form()
+        self.assertHTMLEqual(
+            str(form["title"]),
+            '<input class="book" id="id_title" maxlength="100" name="title" '
+            'type="text" required>',
+        )
+
+    def test_modelformset_factory_labels_overrides(self):
+        BookFormSet = modelformset_factory(
+            Book, fields="__all__", labels={"title": "Name"}
+        )
+        form = BookFormSet.form()
+        self.assertHTMLEqual(
+            form["title"].label_tag(), '<label for="id_title">Name:</label>'
+        )
+        self.assertHTMLEqual(
+            form["title"].legend_tag(),
+            '<legend for="id_title">Name:</legend>',
+        )
+
+    def test_inlineformset_factory_labels_overrides(self):
+        BookFormSet = inlineformset_factory(
+            Author, Book, fields="__all__", labels={"title": "Name"}
+        )
+        form = BookFormSet.form()
+        self.assertHTMLEqual(
+            form["title"].label_tag(), '<label for="id_title">Name:</label>'
+        )
+        self.assertHTMLEqual(
+            form["title"].legend_tag(),
+            '<legend for="id_title">Name:</legend>',
+        )
+
+    def test_modelformset_factory_help_text_overrides(self):
+        BookFormSet = modelformset_factory(
+            Book, fields="__all__", help_texts={"title": "Choose carefully."}
+        )
+        form = BookFormSet.form()
+        self.assertEqual(form["title"].help_text, "Choose carefully.")
+
+    def test_inlineformset_factory_help_text_overrides(self):
+        BookFormSet = inlineformset_factory(
+            Author, Book, fields="__all__", help_texts={"title": "Choose carefully."}
+        )
+        form = BookFormSet.form()
+        self.assertEqual(form["title"].help_text, "Choose carefully.")
+
+    def test_modelformset_factory_error_messages_overrides(self):
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+        BookFormSet = modelformset_factory(
+            Book,
+            fields="__all__",
+            error_messages={"title": {"max_length": "Title too long!!"}},
+        )
+        form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id})
+        form.full_clean()
+        self.assertEqual(form.errors, {"title": ["Title too long!!"]})
+
+    def test_inlineformset_factory_error_messages_overrides(self):
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+        BookFormSet = inlineformset_factory(
+            Author,
+            Book,
+            fields="__all__",
+            error_messages={"title": {"max_length": "Title too long!!"}},
+        )
+        form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id})
+        form.full_clean()
+        self.assertEqual(form.errors, {"title": ["Title too long!!"]})
+
+    def test_modelformset_factory_field_class_overrides(self):
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+        BookFormSet = modelformset_factory(
+            Book,
+            fields="__all__",
+            field_classes={
+                "title": forms.SlugField,
+            },
+        )
+        form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id})
+        self.assertIs(Book._meta.get_field("title").__class__, models.CharField)
+        self.assertIsInstance(form.fields["title"], forms.SlugField)
+
+    def test_inlineformset_factory_field_class_overrides(self):
+        author = Author.objects.create(pk=1, name="Charles Baudelaire")
+        BookFormSet = inlineformset_factory(
+            Author,
+            Book,
+            fields="__all__",
+            field_classes={
+                "title": forms.SlugField,
+            },
+        )
+        form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id})
+        self.assertIs(Book._meta.get_field("title").__class__, models.CharField)
+        self.assertIsInstance(form.fields["title"], forms.SlugField)
+
+    def test_modelformset_factory_absolute_max(self):
+        AuthorFormSet = modelformset_factory(
+            Author, fields="__all__", absolute_max=1500
+        )
+        data = {
+            "form-TOTAL_FORMS": "1501",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "0",
+        }
+        formset = AuthorFormSet(data=data)
+        self.assertIs(formset.is_valid(), False)
+        self.assertEqual(len(formset.forms), 1500)
+        self.assertEqual(
+            formset.non_form_errors(),
+            ["Please submit at most 1000 forms."],
+        )
+
+    def test_modelformset_factory_absolute_max_with_max_num(self):
+        AuthorFormSet = modelformset_factory(
+            Author,
+            fields="__all__",
+            max_num=20,
+            absolute_max=100,
+        )
+        data = {
+            "form-TOTAL_FORMS": "101",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "0",
+        }
+        formset = AuthorFormSet(data=data)
+        self.assertIs(formset.is_valid(), False)
+        self.assertEqual(len(formset.forms), 100)
+        self.assertEqual(
+            formset.non_form_errors(),
+            ["Please submit at most 20 forms."],
+        )
+
+    def test_inlineformset_factory_absolute_max(self):
+        author = Author.objects.create(name="Charles Baudelaire")
+        BookFormSet = inlineformset_factory(
+            Author,
+            Book,
+            fields="__all__",
+            absolute_max=1500,
+        )
+        data = {
+            "book_set-TOTAL_FORMS": "1501",
+            "book_set-INITIAL_FORMS": "0",
+            "book_set-MAX_NUM_FORMS": "0",
+        }
+        formset = BookFormSet(data, instance=author)
+        self.assertIs(formset.is_valid(), False)
+        self.assertEqual(len(formset.forms), 1500)
+        self.assertEqual(
+            formset.non_form_errors(),
+            ["Please submit at most 1000 forms."],
+        )
+
+    def test_inlineformset_factory_absolute_max_with_max_num(self):
+        author = Author.objects.create(name="Charles Baudelaire")
+        BookFormSet = inlineformset_factory(
+            Author,
+            Book,
+            fields="__all__",
+            max_num=20,
+            absolute_max=100,
+        )
+        data = {
+            "book_set-TOTAL_FORMS": "101",
+            "book_set-INITIAL_FORMS": "0",
+            "book_set-MAX_NUM_FORMS": "0",
+        }
+        formset = BookFormSet(data, instance=author)
+        self.assertIs(formset.is_valid(), False)
+        self.assertEqual(len(formset.forms), 100)
+        self.assertEqual(
+            formset.non_form_errors(),
+            ["Please submit at most 20 forms."],
+        )
+
+    def test_modelformset_factory_can_delete_extra(self):
+        AuthorFormSet = modelformset_factory(
+            Author,
+            fields="__all__",
+            can_delete=True,
+            can_delete_extra=True,
+            extra=2,
+        )
+        formset = AuthorFormSet()
+        self.assertEqual(len(formset), 2)
+        self.assertIn("DELETE", formset.forms[0].fields)
+        self.assertIn("DELETE", formset.forms[1].fields)
+
+    def test_modelformset_factory_disable_delete_extra(self):
+        AuthorFormSet = modelformset_factory(
+            Author,
+            fields="__all__",
+            can_delete=True,
+            can_delete_extra=False,
+            extra=2,
+        )
+        formset = AuthorFormSet()
+        self.assertEqual(len(formset), 2)
+        self.assertNotIn("DELETE", formset.forms[0].fields)
+        self.assertNotIn("DELETE", formset.forms[1].fields)
+
+    def test_inlineformset_factory_can_delete_extra(self):
+        BookFormSet = inlineformset_factory(
+            Author,
+            Book,
+            fields="__all__",
+            can_delete=True,
+            can_delete_extra=True,
+            extra=2,
+        )
+        formset = BookFormSet()
+        self.assertEqual(len(formset), 2)
+        self.assertIn("DELETE", formset.forms[0].fields)
+        self.assertIn("DELETE", formset.forms[1].fields)
+
+    def test_inlineformset_factory_can_not_delete_extra(self):
+        BookFormSet = inlineformset_factory(
+            Author,
+            Book,
+            fields="__all__",
+            can_delete=True,
+            can_delete_extra=False,
+            extra=2,
+        )
+        formset = BookFormSet()
+        self.assertEqual(len(formset), 2)
+        self.assertNotIn("DELETE", formset.forms[0].fields)
+        self.assertNotIn("DELETE", formset.forms[1].fields)
+
+    def test_inlineformset_factory_passes_renderer(self):
+        from django.forms.renderers import Jinja2
+
+        renderer = Jinja2()
+        BookFormSet = inlineformset_factory(
+            Author,
+            Book,
+            fields="__all__",
+            renderer=renderer,
+        )
+        formset = BookFormSet()
+        self.assertEqual(formset.renderer, renderer)
+
+    def test_modelformset_factory_passes_renderer(self):
+        from django.forms.renderers import Jinja2
+
+        renderer = Jinja2()
+        BookFormSet = modelformset_factory(Author, fields="__all__", renderer=renderer)
+        formset = BookFormSet()
+        self.assertEqual(formset.renderer, renderer)

testbed/django__django/tests/model_formsets_regress/tests.py

@@ -0,0 +1,586 @@
+from django import forms
+from django.forms.formsets import DELETION_FIELD_NAME, BaseFormSet
+from django.forms.models import (
+    BaseModelFormSet,
+    inlineformset_factory,
+    modelform_factory,
+    modelformset_factory,
+)
+from django.forms.utils import ErrorDict, ErrorList
+from django.test import TestCase
+
+from .models import (
+    Host,
+    Manager,
+    Network,
+    ProfileNetwork,
+    Restaurant,
+    User,
+    UserPreferences,
+    UserProfile,
+    UserSite,
+)
+
+
+class InlineFormsetTests(TestCase):
+    def test_formset_over_to_field(self):
+        """
+        A formset over a ForeignKey with a to_field can be saved.
+        """
+        Form = modelform_factory(User, fields="__all__")
+        FormSet = inlineformset_factory(User, UserSite, fields="__all__")
+
+        # Instantiate the Form and FormSet to prove
+        # you can create a form with no data
+        form = Form()
+        form_set = FormSet(instance=User())
+
+        # Now create a new User and UserSite instance
+        data = {
+            "serial": "1",
+            "username": "apollo13",
+            "usersite_set-TOTAL_FORMS": "1",
+            "usersite_set-INITIAL_FORMS": "0",
+            "usersite_set-MAX_NUM_FORMS": "0",
+            "usersite_set-0-data": "10",
+            "usersite_set-0-user": "apollo13",
+        }
+        user = User()
+        form = Form(data)
+        if form.is_valid():
+            user = form.save()
+        else:
+            self.fail("Errors found on form:%s" % form_set)
+
+        form_set = FormSet(data, instance=user)
+        if form_set.is_valid():
+            form_set.save()
+            usersite = UserSite.objects.values()
+            self.assertEqual(usersite[0]["data"], 10)
+            self.assertEqual(usersite[0]["user_id"], "apollo13")
+        else:
+            self.fail("Errors found on formset:%s" % form_set.errors)
+
+        # Now update the UserSite instance
+        data = {
+            "usersite_set-TOTAL_FORMS": "1",
+            "usersite_set-INITIAL_FORMS": "1",
+            "usersite_set-MAX_NUM_FORMS": "0",
+            "usersite_set-0-id": str(usersite[0]["id"]),
+            "usersite_set-0-data": "11",
+            "usersite_set-0-user": "apollo13",
+        }
+        form_set = FormSet(data, instance=user)
+        if form_set.is_valid():
+            form_set.save()
+            usersite = UserSite.objects.values()
+            self.assertEqual(usersite[0]["data"], 11)
+            self.assertEqual(usersite[0]["user_id"], "apollo13")
+        else:
+            self.fail("Errors found on formset:%s" % form_set.errors)
+
+        # Now add a new UserSite instance
+        data = {
+            "usersite_set-TOTAL_FORMS": "2",
+            "usersite_set-INITIAL_FORMS": "1",
+            "usersite_set-MAX_NUM_FORMS": "0",
+            "usersite_set-0-id": str(usersite[0]["id"]),
+            "usersite_set-0-data": "11",
+            "usersite_set-0-user": "apollo13",
+            "usersite_set-1-data": "42",
+            "usersite_set-1-user": "apollo13",
+        }
+        form_set = FormSet(data, instance=user)
+        if form_set.is_valid():
+            form_set.save()
+            usersite = UserSite.objects.values().order_by("data")
+            self.assertEqual(usersite[0]["data"], 11)
+            self.assertEqual(usersite[0]["user_id"], "apollo13")
+            self.assertEqual(usersite[1]["data"], 42)
+            self.assertEqual(usersite[1]["user_id"], "apollo13")
+        else:
+            self.fail("Errors found on formset:%s" % form_set.errors)
+
+    def test_formset_over_inherited_model(self):
+        """
+        A formset over a ForeignKey with a to_field can be saved.
+        """
+        Form = modelform_factory(Restaurant, fields="__all__")
+        FormSet = inlineformset_factory(Restaurant, Manager, fields="__all__")
+
+        # Instantiate the Form and FormSet to prove
+        # you can create a form with no data
+        form = Form()
+        form_set = FormSet(instance=Restaurant())
+
+        # Now create a new Restaurant and Manager instance
+        data = {
+            "name": "Guido's House of Pasta",
+            "manager_set-TOTAL_FORMS": "1",
+            "manager_set-INITIAL_FORMS": "0",
+            "manager_set-MAX_NUM_FORMS": "0",
+            "manager_set-0-name": "Guido Van Rossum",
+        }
+        restaurant = User()
+        form = Form(data)
+        if form.is_valid():
+            restaurant = form.save()
+        else:
+            self.fail("Errors found on form:%s" % form_set)
+
+        form_set = FormSet(data, instance=restaurant)
+        if form_set.is_valid():
+            form_set.save()
+            manager = Manager.objects.values()
+            self.assertEqual(manager[0]["name"], "Guido Van Rossum")
+        else:
+            self.fail("Errors found on formset:%s" % form_set.errors)
+
+        # Now update the Manager instance
+        data = {
+            "manager_set-TOTAL_FORMS": "1",
+            "manager_set-INITIAL_FORMS": "1",
+            "manager_set-MAX_NUM_FORMS": "0",
+            "manager_set-0-id": str(manager[0]["id"]),
+            "manager_set-0-name": "Terry Gilliam",
+        }
+        form_set = FormSet(data, instance=restaurant)
+        if form_set.is_valid():
+            form_set.save()
+            manager = Manager.objects.values()
+            self.assertEqual(manager[0]["name"], "Terry Gilliam")
+        else:
+            self.fail("Errors found on formset:%s" % form_set.errors)
+
+        # Now add a new Manager instance
+        data = {
+            "manager_set-TOTAL_FORMS": "2",
+            "manager_set-INITIAL_FORMS": "1",
+            "manager_set-MAX_NUM_FORMS": "0",
+            "manager_set-0-id": str(manager[0]["id"]),
+            "manager_set-0-name": "Terry Gilliam",
+            "manager_set-1-name": "John Cleese",
+        }
+        form_set = FormSet(data, instance=restaurant)
+        if form_set.is_valid():
+            form_set.save()
+            manager = Manager.objects.values().order_by("name")
+            self.assertEqual(manager[0]["name"], "John Cleese")
+            self.assertEqual(manager[1]["name"], "Terry Gilliam")
+        else:
+            self.fail("Errors found on formset:%s" % form_set.errors)
+
+    def test_inline_model_with_to_field(self):
+        """
+        #13794 --- An inline model with a to_field of a formset with instance
+        has working relations.
+        """
+        FormSet = inlineformset_factory(User, UserSite, exclude=("is_superuser",))
+
+        user = User.objects.create(username="guido", serial=1337)
+        UserSite.objects.create(user=user, data=10)
+        formset = FormSet(instance=user)
+
+        # Testing the inline model's relation
+        self.assertEqual(formset[0].instance.user_id, "guido")
+
+    def test_inline_model_with_primary_to_field(self):
+        """An inline model with a OneToOneField with to_field & primary key."""
+        FormSet = inlineformset_factory(
+            User, UserPreferences, exclude=("is_superuser",)
+        )
+        user = User.objects.create(username="guido", serial=1337)
+        UserPreferences.objects.create(user=user, favorite_number=10)
+        formset = FormSet(instance=user)
+        self.assertEqual(formset[0].fields["user"].initial, "guido")
+
+    def test_inline_model_with_to_field_to_rel(self):
+        """
+        #13794 --- An inline model with a to_field to a related field of a
+        formset with instance has working relations.
+        """
+        FormSet = inlineformset_factory(UserProfile, ProfileNetwork, exclude=[])
+
+        user = User.objects.create(username="guido", serial=1337, pk=1)
+        self.assertEqual(user.pk, 1)
+        profile = UserProfile.objects.create(user=user, about="about", pk=2)
+        self.assertEqual(profile.pk, 2)
+        ProfileNetwork.objects.create(profile=profile, network=10, identifier=10)
+        formset = FormSet(instance=profile)
+
+        # Testing the inline model's relation
+        self.assertEqual(formset[0].instance.profile_id, 1)
+
+    def test_formset_with_none_instance(self):
+        "A formset with instance=None can be created. Regression for #11872"
+        Form = modelform_factory(User, fields="__all__")
+        FormSet = inlineformset_factory(User, UserSite, fields="__all__")
+
+        # Instantiate the Form and FormSet to prove
+        # you can create a formset with an instance of None
+        Form(instance=None)
+        FormSet(instance=None)
+
+    def test_empty_fields_on_modelformset(self):
+        """
+        No fields passed to modelformset_factory() should result in no fields
+        on returned forms except for the id (#14119).
+        """
+        UserFormSet = modelformset_factory(User, fields=())
+        formset = UserFormSet()
+        for form in formset.forms:
+            self.assertIn("id", form.fields)
+            self.assertEqual(len(form.fields), 1)
+
+    def test_save_as_new_with_new_inlines(self):
+        """
+        Existing and new inlines are saved with save_as_new.
+
+        Regression for #14938.
+        """
+        efnet = Network.objects.create(name="EFNet")
+        host1 = Host.objects.create(hostname="irc.he.net", network=efnet)
+
+        HostFormSet = inlineformset_factory(Network, Host, fields="__all__")
+
+        # Add a new host, modify previous host, and save-as-new
+        data = {
+            "host_set-TOTAL_FORMS": "2",
+            "host_set-INITIAL_FORMS": "1",
+            "host_set-MAX_NUM_FORMS": "0",
+            "host_set-0-id": str(host1.id),
+            "host_set-0-hostname": "tranquility.hub.dal.net",
+            "host_set-1-hostname": "matrix.de.eu.dal.net",
+        }
+
+        # To save a formset as new, it needs a new hub instance
+        dalnet = Network.objects.create(name="DALnet")
+        formset = HostFormSet(data, instance=dalnet, save_as_new=True)
+
+        self.assertTrue(formset.is_valid())
+        formset.save()
+        self.assertQuerySetEqual(
+            dalnet.host_set.order_by("hostname"),
+            Host.objects.filter(
+                hostname__in=[
+                    "matrix.de.eu.dal.net",
+                    "tranquility.hub.dal.net",
+                ]
+            ).order_by("hostname"),
+        )
+
+    def test_initial_data(self):
+        user = User.objects.create(username="bibi", serial=1)
+        UserSite.objects.create(user=user, data=7)
+        FormSet = inlineformset_factory(User, UserSite, extra=2, fields="__all__")
+
+        formset = FormSet(instance=user, initial=[{"data": 41}, {"data": 42}])
+        self.assertEqual(formset.forms[0].initial["data"], 7)
+        self.assertEqual(formset.extra_forms[0].initial["data"], 41)
+        self.assertIn('value="42"', formset.extra_forms[1].as_p())
+
+
+class FormsetTests(TestCase):
+    def test_error_class(self):
+        """
+        Test the type of Formset and Form error attributes
+        """
+        Formset = modelformset_factory(User, fields="__all__")
+        data = {
+            "form-TOTAL_FORMS": "2",
+            "form-INITIAL_FORMS": "0",
+            "form-MAX_NUM_FORMS": "0",
+            "form-0-id": "",
+            "form-0-username": "apollo13",
+            "form-0-serial": "1",
+            "form-1-id": "",
+            "form-1-username": "apollo13",
+            "form-1-serial": "2",
+        }
+        formset = Formset(data)
+        # check if the returned error classes are correct
+        # note: formset.errors returns a list as documented
+        self.assertIsInstance(formset.errors, list)
+        self.assertIsInstance(formset.non_form_errors(), ErrorList)
+        for form in formset.forms:
+            self.assertIsInstance(form.errors, ErrorDict)
+            self.assertIsInstance(form.non_field_errors(), ErrorList)
+
+    def test_initial_data(self):
+        User.objects.create(username="bibi", serial=1)
+        Formset = modelformset_factory(User, fields="__all__", extra=2)
+        formset = Formset(initial=[{"username": "apollo11"}, {"username": "apollo12"}])
+        self.assertEqual(formset.forms[0].initial["username"], "bibi")
+        self.assertEqual(formset.extra_forms[0].initial["username"], "apollo11")
+        self.assertIn('value="apollo12"', formset.extra_forms[1].as_p())
+
+    def test_extraneous_query_is_not_run(self):
+        Formset = modelformset_factory(Network, fields="__all__")
+        data = {
+            "test-TOTAL_FORMS": "1",
+            "test-INITIAL_FORMS": "0",
+            "test-MAX_NUM_FORMS": "",
+            "test-0-name": "Random Place",
+        }
+        with self.assertNumQueries(1):
+            formset = Formset(data, prefix="test")
+            formset.save()
+
+
+class CustomWidget(forms.widgets.TextInput):
+    pass
+
+
+class UserSiteForm(forms.ModelForm):
+    class Meta:
+        model = UserSite
+        fields = "__all__"
+        widgets = {
+            "id": CustomWidget,
+            "data": CustomWidget,
+        }
+        localized_fields = ("data",)
+
+
+class Callback:
+    def __init__(self):
+        self.log = []
+
+    def __call__(self, db_field, **kwargs):
+        self.log.append((db_field, kwargs))
+        return db_field.formfield(**kwargs)
+
+
+class FormfieldCallbackTests(TestCase):
+    """
+    Regression for #13095 and #17683: Using base forms with widgets
+    defined in Meta should not raise errors and BaseModelForm should respect
+    the specified pk widget.
+    """
+
+    def test_inlineformset_factory_default(self):
+        Formset = inlineformset_factory(
+            User, UserSite, form=UserSiteForm, fields="__all__"
+        )
+        form = Formset().forms[0]
+        self.assertIsInstance(form["id"].field.widget, CustomWidget)
+        self.assertIsInstance(form["data"].field.widget, CustomWidget)
+        self.assertFalse(form.fields["id"].localize)
+        self.assertTrue(form.fields["data"].localize)
+
+    def test_modelformset_factory_default(self):
+        Formset = modelformset_factory(UserSite, form=UserSiteForm)
+        form = Formset().forms[0]
+        self.assertIsInstance(form["id"].field.widget, CustomWidget)
+        self.assertIsInstance(form["data"].field.widget, CustomWidget)
+        self.assertFalse(form.fields["id"].localize)
+        self.assertTrue(form.fields["data"].localize)
+
+    def assertCallbackCalled(self, callback):
+        id_field, user_field, data_field = UserSite._meta.fields
+        expected_log = [
+            (id_field, {"widget": CustomWidget}),
+            (user_field, {}),
+            (data_field, {"widget": CustomWidget, "localize": True}),
+        ]
+        self.assertEqual(callback.log, expected_log)
+
+    def test_inlineformset_custom_callback(self):
+        callback = Callback()
+        inlineformset_factory(
+            User,
+            UserSite,
+            form=UserSiteForm,
+            formfield_callback=callback,
+            fields="__all__",
+        )
+        self.assertCallbackCalled(callback)
+
+    def test_modelformset_custom_callback(self):
+        callback = Callback()
+        modelformset_factory(UserSite, form=UserSiteForm, formfield_callback=callback)
+        self.assertCallbackCalled(callback)
+
+
+class BaseCustomDeleteFormSet(BaseFormSet):
+    """
+    A formset mix-in that lets a form decide if it's to be deleted.
+    Works for BaseFormSets. Also works for ModelFormSets with #14099 fixed.
+
+    form.should_delete() is called. The formset delete field is also suppressed.
+    """
+
+    def add_fields(self, form, index):
+        super().add_fields(form, index)
+        self.can_delete = True
+        if DELETION_FIELD_NAME in form.fields:
+            del form.fields[DELETION_FIELD_NAME]
+
+    def _should_delete_form(self, form):
+        return hasattr(form, "should_delete") and form.should_delete()
+
+
+class FormfieldShouldDeleteFormTests(TestCase):
+    """
+    BaseModelFormSet should use ModelFormSet method _should_delete_form.
+    """
+
+    class BaseCustomDeleteModelFormSet(BaseModelFormSet, BaseCustomDeleteFormSet):
+        """Model FormSet with CustomDelete MixIn"""
+
+    class CustomDeleteUserForm(forms.ModelForm):
+        """A model form with a 'should_delete' method"""
+
+        class Meta:
+            model = User
+            fields = "__all__"
+
+        def should_delete(self):
+            """Delete form if odd serial."""
+            return self.instance.serial % 2 != 0
+
+    NormalFormset = modelformset_factory(
+        User, form=CustomDeleteUserForm, can_delete=True
+    )
+    DeleteFormset = modelformset_factory(
+        User, form=CustomDeleteUserForm, formset=BaseCustomDeleteModelFormSet
+    )
+
+    data = {
+        "form-TOTAL_FORMS": "4",
+        "form-INITIAL_FORMS": "0",
+        "form-MAX_NUM_FORMS": "4",
+        "form-0-username": "John",
+        "form-0-serial": "1",
+        "form-1-username": "Paul",
+        "form-1-serial": "2",
+        "form-2-username": "George",
+        "form-2-serial": "3",
+        "form-3-username": "Ringo",
+        "form-3-serial": "5",
+    }
+
+    delete_all_ids = {
+        "form-0-DELETE": "1",
+        "form-1-DELETE": "1",
+        "form-2-DELETE": "1",
+        "form-3-DELETE": "1",
+    }
+
+    def test_init_database(self):
+        """Add test data to database via formset"""
+        formset = self.NormalFormset(self.data)
+        self.assertTrue(formset.is_valid())
+        self.assertEqual(len(formset.save()), 4)
+
+    def test_no_delete(self):
+        """Verify base formset doesn't modify database"""
+        # reload database
+        self.test_init_database()
+
+        # pass standard data dict & see none updated
+        data = dict(self.data)
+        data["form-INITIAL_FORMS"] = 4
+        data.update(
+            {
+                "form-%d-id" % i: user.pk
+                for i, user in enumerate(User.objects.order_by("pk"))
+            }
+        )
+        formset = self.NormalFormset(data, queryset=User.objects.all())
+        self.assertTrue(formset.is_valid())
+        self.assertEqual(len(formset.save()), 0)
+        self.assertEqual(len(User.objects.all()), 4)
+
+    def test_all_delete(self):
+        """Verify base formset honors DELETE field"""
+        # reload database
+        self.test_init_database()
+
+        # create data dict with all fields marked for deletion
+        data = dict(self.data)
+        data["form-INITIAL_FORMS"] = 4
+        data.update(
+            {"form-%d-id" % i: user.pk for i, user in enumerate(User.objects.all())}
+        )
+        data.update(self.delete_all_ids)
+        formset = self.NormalFormset(data, queryset=User.objects.all())
+        self.assertTrue(formset.is_valid())
+        self.assertEqual(len(formset.save()), 0)
+        self.assertEqual(len(User.objects.all()), 0)
+
+    def test_custom_delete(self):
+        """Verify DeleteFormset ignores DELETE field and uses form method"""
+        # reload database
+        self.test_init_database()
+
+        # Create formset with custom Delete function
+        # create data dict with all fields marked for deletion
+        data = dict(self.data)
+        data["form-INITIAL_FORMS"] = 4
+        data.update(
+            {
+                "form-%d-id" % i: user.pk
+                for i, user in enumerate(User.objects.order_by("pk"))
+            }
+        )
+        data.update(self.delete_all_ids)
+        formset = self.DeleteFormset(data, queryset=User.objects.all())
+
+        # Three with odd serial values were deleted.
+        self.assertTrue(formset.is_valid())
+        self.assertEqual(len(formset.save()), 0)
+        self.assertEqual(User.objects.count(), 1)
+
+        # No odd serial values left.
+        odd_serials = [user.serial for user in User.objects.all() if user.serial % 2]
+        self.assertEqual(len(odd_serials), 0)
+
+
+class RedeleteTests(TestCase):
+    def test_resubmit(self):
+        u = User.objects.create(username="foo", serial=1)
+        us = UserSite.objects.create(user=u, data=7)
+        formset_cls = inlineformset_factory(User, UserSite, fields="__all__")
+        data = {
+            "serial": "1",
+            "username": "foo",
+            "usersite_set-TOTAL_FORMS": "1",
+            "usersite_set-INITIAL_FORMS": "1",
+            "usersite_set-MAX_NUM_FORMS": "1",
+            "usersite_set-0-id": str(us.pk),
+            "usersite_set-0-data": "7",
+            "usersite_set-0-user": "foo",
+            "usersite_set-0-DELETE": "1",
+        }
+        formset = formset_cls(data, instance=u)
+        self.assertTrue(formset.is_valid())
+        formset.save()
+        self.assertEqual(UserSite.objects.count(), 0)
+        formset = formset_cls(data, instance=u)
+        # Even if the "us" object isn't in the DB any more, the form
+        # validates.
+        self.assertTrue(formset.is_valid())
+        formset.save()
+        self.assertEqual(UserSite.objects.count(), 0)
+
+    def test_delete_already_deleted(self):
+        u = User.objects.create(username="foo", serial=1)
+        us = UserSite.objects.create(user=u, data=7)
+        formset_cls = inlineformset_factory(User, UserSite, fields="__all__")
+        data = {
+            "serial": "1",
+            "username": "foo",
+            "usersite_set-TOTAL_FORMS": "1",
+            "usersite_set-INITIAL_FORMS": "1",
+            "usersite_set-MAX_NUM_FORMS": "1",
+            "usersite_set-0-id": str(us.pk),
+            "usersite_set-0-data": "7",
+            "usersite_set-0-user": "foo",
+            "usersite_set-0-DELETE": "1",
+        }
+        formset = formset_cls(data, instance=u)
+        us.delete()
+        self.assertTrue(formset.is_valid())
+        formset.save()
+        self.assertEqual(UserSite.objects.count(), 0)

testbed/django__django/tests/model_indexes/models.py

@@ -0,0 +1,39 @@
+from django.db import models
+
+
+class Book(models.Model):
+    title = models.CharField(max_length=50)
+    author = models.CharField(max_length=50)
+    pages = models.IntegerField(db_column="page_count")
+    shortcut = models.CharField(max_length=50, db_tablespace="idx_tbls")
+    isbn = models.CharField(max_length=50, db_tablespace="idx_tbls")
+    barcode = models.CharField(max_length=31)
+
+    class Meta:
+        indexes = [
+            models.Index(fields=["title"]),
+            models.Index(fields=["isbn", "id"]),
+            models.Index(
+                fields=["barcode"], name="%(app_label)s_%(class)s_barcode_idx"
+            ),
+        ]
+
+
+class AbstractModel(models.Model):
+    name = models.CharField(max_length=50)
+    shortcut = models.CharField(max_length=3)
+
+    class Meta:
+        abstract = True
+        indexes = [
+            models.Index(fields=["name"]),
+            models.Index(fields=["shortcut"], name="%(app_label)s_%(class)s_idx"),
+        ]
+
+
+class ChildModel1(AbstractModel):
+    pass
+
+
+class ChildModel2(AbstractModel):
+    pass

testbed/django__django/tests/model_indexes/tests.py

@@ -0,0 +1,372 @@
+from unittest import mock
+
+from django.conf import settings
+from django.db import connection, models
+from django.db.models.functions import Lower, Upper
+from django.test import SimpleTestCase, TestCase, override_settings, skipUnlessDBFeature
+from django.test.utils import isolate_apps
+
+from .models import Book, ChildModel1, ChildModel2
+
+
+class SimpleIndexesTests(SimpleTestCase):
+    def test_suffix(self):
+        self.assertEqual(models.Index.suffix, "idx")
+
+    def test_repr(self):
+        index = models.Index(fields=["title"])
+        named_index = models.Index(fields=["title"], name="title_idx")
+        multi_col_index = models.Index(fields=["title", "author"])
+        partial_index = models.Index(
+            fields=["title"], name="long_books_idx", condition=models.Q(pages__gt=400)
+        )
+        covering_index = models.Index(
+            fields=["title"],
+            name="include_idx",
+            include=["author", "pages"],
+        )
+        opclasses_index = models.Index(
+            fields=["headline", "body"],
+            name="opclasses_idx",
+            opclasses=["varchar_pattern_ops", "text_pattern_ops"],
+        )
+        func_index = models.Index(Lower("title"), "subtitle", name="book_func_idx")
+        tablespace_index = models.Index(
+            fields=["title"],
+            db_tablespace="idx_tbls",
+            name="book_tablespace_idx",
+        )
+        self.assertEqual(repr(index), "<Index: fields=['title']>")
+        self.assertEqual(
+            repr(named_index),
+            "<Index: fields=['title'] name='title_idx'>",
+        )
+        self.assertEqual(repr(multi_col_index), "<Index: fields=['title', 'author']>")
+        self.assertEqual(
+            repr(partial_index),
+            "<Index: fields=['title'] name='long_books_idx' "
+            "condition=(AND: ('pages__gt', 400))>",
+        )
+        self.assertEqual(
+            repr(covering_index),
+            "<Index: fields=['title'] name='include_idx' "
+            "include=('author', 'pages')>",
+        )
+        self.assertEqual(
+            repr(opclasses_index),
+            "<Index: fields=['headline', 'body'] name='opclasses_idx' "
+            "opclasses=['varchar_pattern_ops', 'text_pattern_ops']>",
+        )
+        self.assertEqual(
+            repr(func_index),
+            "<Index: expressions=(Lower(F(title)), F(subtitle)) "
+            "name='book_func_idx'>",
+        )
+        self.assertEqual(
+            repr(tablespace_index),
+            "<Index: fields=['title'] name='book_tablespace_idx' "
+            "db_tablespace='idx_tbls'>",
+        )
+
+    def test_eq(self):
+        index = models.Index(fields=["title"])
+        same_index = models.Index(fields=["title"])
+        another_index = models.Index(fields=["title", "author"])
+        index.model = Book
+        same_index.model = Book
+        another_index.model = Book
+        self.assertEqual(index, same_index)
+        self.assertEqual(index, mock.ANY)
+        self.assertNotEqual(index, another_index)
+
+    def test_eq_func(self):
+        index = models.Index(Lower("title"), models.F("author"), name="book_func_idx")
+        same_index = models.Index(Lower("title"), "author", name="book_func_idx")
+        another_index = models.Index(Lower("title"), name="book_func_idx")
+        self.assertEqual(index, same_index)
+        self.assertEqual(index, mock.ANY)
+        self.assertNotEqual(index, another_index)
+
+    def test_index_fields_type(self):
+        with self.assertRaisesMessage(
+            ValueError, "Index.fields must be a list or tuple."
+        ):
+            models.Index(fields="title")
+
+    def test_index_fields_strings(self):
+        msg = "Index.fields must contain only strings with field names."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index(fields=[models.F("title")])
+
+    def test_fields_tuple(self):
+        self.assertEqual(models.Index(fields=("title",)).fields, ["title"])
+
+    def test_requires_field_or_expression(self):
+        msg = "At least one field or expression is required to define an index."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index()
+
+    def test_expressions_and_fields_mutually_exclusive(self):
+        msg = "Index.fields and expressions are mutually exclusive."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index(Upper("foo"), fields=["field"])
+
+    def test_opclasses_requires_index_name(self):
+        with self.assertRaisesMessage(
+            ValueError, "An index must be named to use opclasses."
+        ):
+            models.Index(opclasses=["jsonb_path_ops"])
+
+    def test_opclasses_requires_list_or_tuple(self):
+        with self.assertRaisesMessage(
+            ValueError, "Index.opclasses must be a list or tuple."
+        ):
+            models.Index(
+                name="test_opclass", fields=["field"], opclasses="jsonb_path_ops"
+            )
+
+    def test_opclasses_and_fields_same_length(self):
+        msg = "Index.fields and Index.opclasses must have the same number of elements."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index(
+                name="test_opclass",
+                fields=["field", "other"],
+                opclasses=["jsonb_path_ops"],
+            )
+
+    def test_condition_requires_index_name(self):
+        with self.assertRaisesMessage(
+            ValueError, "An index must be named to use condition."
+        ):
+            models.Index(condition=models.Q(pages__gt=400))
+
+    def test_expressions_requires_index_name(self):
+        msg = "An index must be named to use expressions."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index(Lower("field"))
+
+    def test_expressions_with_opclasses(self):
+        msg = (
+            "Index.opclasses cannot be used with expressions. Use "
+            "django.contrib.postgres.indexes.OpClass() instead."
+        )
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index(
+                Lower("field"),
+                name="test_func_opclass",
+                opclasses=["jsonb_path_ops"],
+            )
+
+    def test_condition_must_be_q(self):
+        with self.assertRaisesMessage(
+            ValueError, "Index.condition must be a Q instance."
+        ):
+            models.Index(condition="invalid", name="long_book_idx")
+
+    def test_include_requires_list_or_tuple(self):
+        msg = "Index.include must be a list or tuple."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index(name="test_include", fields=["field"], include="other")
+
+    def test_include_requires_index_name(self):
+        msg = "A covering index must be named."
+        with self.assertRaisesMessage(ValueError, msg):
+            models.Index(fields=["field"], include=["other"])
+
+    def test_name_auto_generation(self):
+        index = models.Index(fields=["author"])
+        index.set_name_with_model(Book)
+        self.assertEqual(index.name, "model_index_author_0f5565_idx")
+
+        # '-' for DESC columns should be accounted for in the index name.
+        index = models.Index(fields=["-author"])
+        index.set_name_with_model(Book)
+        self.assertEqual(index.name, "model_index_author_708765_idx")
+
+        # fields may be truncated in the name. db_column is used for naming.
+        long_field_index = models.Index(fields=["pages"])
+        long_field_index.set_name_with_model(Book)
+        self.assertEqual(long_field_index.name, "model_index_page_co_69235a_idx")
+
+        # suffix can't be longer than 3 characters.
+        long_field_index.suffix = "suff"
+        msg = (
+            "Index too long for multiple database support. Is self.suffix "
+            "longer than 3 characters?"
+        )
+        with self.assertRaisesMessage(ValueError, msg):
+            long_field_index.set_name_with_model(Book)
+
+    @isolate_apps("model_indexes")
+    def test_name_auto_generation_with_quoted_db_table(self):
+        class QuotedDbTable(models.Model):
+            name = models.CharField(max_length=50)
+
+            class Meta:
+                db_table = '"t_quoted"'
+
+        index = models.Index(fields=["name"])
+        index.set_name_with_model(QuotedDbTable)
+        self.assertEqual(index.name, "t_quoted_name_e4ed1b_idx")
+
+    def test_deconstruction(self):
+        index = models.Index(fields=["title"], db_tablespace="idx_tbls")
+        index.set_name_with_model(Book)
+        path, args, kwargs = index.deconstruct()
+        self.assertEqual(path, "django.db.models.Index")
+        self.assertEqual(args, ())
+        self.assertEqual(
+            kwargs,
+            {
+                "fields": ["title"],
+                "name": "model_index_title_196f42_idx",
+                "db_tablespace": "idx_tbls",
+            },
+        )
+
+    def test_deconstruct_with_condition(self):
+        index = models.Index(
+            name="big_book_index",
+            fields=["title"],
+            condition=models.Q(pages__gt=400),
+        )
+        index.set_name_with_model(Book)
+        path, args, kwargs = index.deconstruct()
+        self.assertEqual(path, "django.db.models.Index")
+        self.assertEqual(args, ())
+        self.assertEqual(
+            kwargs,
+            {
+                "fields": ["title"],
+                "name": "model_index_title_196f42_idx",
+                "condition": models.Q(pages__gt=400),
+            },
+        )
+
+    def test_deconstruct_with_include(self):
+        index = models.Index(
+            name="book_include_idx",
+            fields=["title"],
+            include=["author"],
+        )
+        index.set_name_with_model(Book)
+        path, args, kwargs = index.deconstruct()
+        self.assertEqual(path, "django.db.models.Index")
+        self.assertEqual(args, ())
+        self.assertEqual(
+            kwargs,
+            {
+                "fields": ["title"],
+                "name": "model_index_title_196f42_idx",
+                "include": ("author",),
+            },
+        )
+
+    def test_deconstruct_with_expressions(self):
+        index = models.Index(Upper("title"), name="book_func_idx")
+        path, args, kwargs = index.deconstruct()
+        self.assertEqual(path, "django.db.models.Index")
+        self.assertEqual(args, (Upper("title"),))
+        self.assertEqual(kwargs, {"name": "book_func_idx"})
+
+    def test_clone(self):
+        index = models.Index(fields=["title"])
+        new_index = index.clone()
+        self.assertIsNot(index, new_index)
+        self.assertEqual(index.fields, new_index.fields)
+
+    def test_clone_with_expressions(self):
+        index = models.Index(Upper("title"), name="book_func_idx")
+        new_index = index.clone()
+        self.assertIsNot(index, new_index)
+        self.assertEqual(index.expressions, new_index.expressions)
+
+    def test_name_set(self):
+        index_names = [index.name for index in Book._meta.indexes]
+        self.assertCountEqual(
+            index_names,
+            [
+                "model_index_title_196f42_idx",
+                "model_index_isbn_34f975_idx",
+                "model_indexes_book_barcode_idx",
+            ],
+        )
+
+    def test_abstract_children(self):
+        index_names = [index.name for index in ChildModel1._meta.indexes]
+        self.assertEqual(
+            index_names,
+            ["model_index_name_440998_idx", "model_indexes_childmodel1_idx"],
+        )
+        index_names = [index.name for index in ChildModel2._meta.indexes]
+        self.assertEqual(
+            index_names,
+            ["model_index_name_b6c374_idx", "model_indexes_childmodel2_idx"],
+        )
+
+
+@override_settings(DEFAULT_TABLESPACE=None)
+class IndexesTests(TestCase):
+    @skipUnlessDBFeature("supports_tablespaces")
+    def test_db_tablespace(self):
+        editor = connection.schema_editor()
+        # Index with db_tablespace attribute.
+        for fields in [
+            # Field with db_tablespace specified on model.
+            ["shortcut"],
+            # Field without db_tablespace specified on model.
+            ["author"],
+            # Multi-column with db_tablespaces specified on model.
+            ["shortcut", "isbn"],
+            # Multi-column without db_tablespace specified on model.
+            ["title", "author"],
+        ]:
+            with self.subTest(fields=fields):
+                index = models.Index(fields=fields, db_tablespace="idx_tbls2")
+                self.assertIn(
+                    '"idx_tbls2"', str(index.create_sql(Book, editor)).lower()
+                )
+        # Indexes without db_tablespace attribute.
+        for fields in [["author"], ["shortcut", "isbn"], ["title", "author"]]:
+            with self.subTest(fields=fields):
+                index = models.Index(fields=fields)
+                # The DEFAULT_INDEX_TABLESPACE setting can't be tested because
+                # it's evaluated when the model class is defined. As a
+                # consequence, @override_settings doesn't work.
+                if settings.DEFAULT_INDEX_TABLESPACE:
+                    self.assertIn(
+                        '"%s"' % settings.DEFAULT_INDEX_TABLESPACE,
+                        str(index.create_sql(Book, editor)).lower(),
+                    )
+                else:
+                    self.assertNotIn("TABLESPACE", str(index.create_sql(Book, editor)))
+        # Field with db_tablespace specified on the model and an index without
+        # db_tablespace.
+        index = models.Index(fields=["shortcut"])
+        self.assertIn('"idx_tbls"', str(index.create_sql(Book, editor)).lower())
+
+    @skipUnlessDBFeature("supports_tablespaces")
+    def test_func_with_tablespace(self):
+        # Functional index with db_tablespace attribute.
+        index = models.Index(
+            Lower("shortcut").desc(),
+            name="functional_tbls",
+            db_tablespace="idx_tbls2",
+        )
+        with connection.schema_editor() as editor:
+            sql = str(index.create_sql(Book, editor))
+            self.assertIn(editor.quote_name("idx_tbls2"), sql)
+        # Functional index without db_tablespace attribute.
+        index = models.Index(Lower("shortcut").desc(), name="functional_no_tbls")
+        with connection.schema_editor() as editor:
+            sql = str(index.create_sql(Book, editor))
+            # The DEFAULT_INDEX_TABLESPACE setting can't be tested because it's
+            # evaluated when the model class is defined. As a consequence,
+            # @override_settings doesn't work.
+            if settings.DEFAULT_INDEX_TABLESPACE:
+                self.assertIn(
+                    editor.quote_name(settings.DEFAULT_INDEX_TABLESPACE),
+                    sql,
+                )
+            else:
+                self.assertNotIn("TABLESPACE", sql)

testbed/django__django/tests/model_inheritance/models.py

@@ -0,0 +1,214 @@
+"""
+XX. Model inheritance
+
+Model inheritance exists in two varieties:
+    - abstract base classes which are a way of specifying common
+      information inherited by the subclasses. They don't exist as a separate
+      model.
+    - non-abstract base classes (the default), which are models in their own
+      right with their own database tables and everything. Their subclasses
+      have references back to them, created automatically.
+
+Both styles are demonstrated here.
+"""
+from django.db import models
+
+#
+# Abstract base classes
+#
+
+
+class CommonInfo(models.Model):
+    name = models.CharField(max_length=50)
+    age = models.PositiveIntegerField()
+
+    class Meta:
+        abstract = True
+        ordering = ["name"]
+
+    def __str__(self):
+        return "%s %s" % (self.__class__.__name__, self.name)
+
+
+class Worker(CommonInfo):
+    job = models.CharField(max_length=50)
+
+
+class Student(CommonInfo):
+    school_class = models.CharField(max_length=10)
+
+    class Meta:
+        pass
+
+
+#
+# Abstract base classes with related models
+#
+
+
+class Post(models.Model):
+    title = models.CharField(max_length=50)
+
+
+class Attachment(models.Model):
+    post = models.ForeignKey(
+        Post,
+        models.CASCADE,
+        related_name="attached_%(class)s_set",
+        related_query_name="attached_%(app_label)s_%(class)ss",
+    )
+    content = models.TextField()
+
+    class Meta:
+        abstract = True
+
+
+class Comment(Attachment):
+    is_spam = models.BooleanField(default=False)
+
+
+class Link(Attachment):
+    url = models.URLField()
+
+
+#
+# Multi-table inheritance
+#
+
+
+class Chef(models.Model):
+    name = models.CharField(max_length=50)
+
+
+class Place(models.Model):
+    name = models.CharField(max_length=50)
+    address = models.CharField(max_length=80)
+
+
+class Rating(models.Model):
+    rating = models.IntegerField(null=True, blank=True)
+
+    class Meta:
+        abstract = True
+        ordering = ["-rating"]
+
+
+class Restaurant(Place, Rating):
+    serves_hot_dogs = models.BooleanField(default=False)
+    serves_pizza = models.BooleanField(default=False)
+    chef = models.ForeignKey(Chef, models.SET_NULL, null=True, blank=True)
+
+    class Meta(Rating.Meta):
+        db_table = "my_restaurant"
+
+
+class ItalianRestaurant(Restaurant):
+    serves_gnocchi = models.BooleanField(default=False)
+
+
+class ItalianRestaurantCommonParent(ItalianRestaurant, Place):
+    place_ptr_two = models.OneToOneField(
+        Place, on_delete=models.CASCADE, parent_link=True
+    )
+
+
+class Supplier(Place):
+    customers = models.ManyToManyField(Restaurant, related_name="provider")
+
+
+class CustomSupplier(Supplier):
+    pass
+
+
+class ParkingLot(Place):
+    # An explicit link to the parent (we can control the attribute name).
+    parent = models.OneToOneField(
+        Place, models.CASCADE, primary_key=True, parent_link=True
+    )
+    main_site = models.ForeignKey(Place, models.CASCADE, related_name="lot")
+
+
+#
+# Abstract base classes with related models where the sub-class has the
+# same name in a different app and inherits from the same abstract base
+# class.
+# NOTE: The actual API tests for the following classes are in
+#       model_inheritance_same_model_name/models.py - They are defined
+#       here in order to have the name conflict between apps
+#
+
+
+class Title(models.Model):
+    title = models.CharField(max_length=50)
+
+
+class NamedURL(models.Model):
+    title = models.ForeignKey(
+        Title, models.CASCADE, related_name="attached_%(app_label)s_%(class)s_set"
+    )
+    url = models.URLField()
+
+    class Meta:
+        abstract = True
+
+
+class Mixin:
+    def __init__(self):
+        self.other_attr = 1
+        super().__init__()
+
+
+class MixinModel(models.Model, Mixin):
+    pass
+
+
+class Base(models.Model):
+    titles = models.ManyToManyField(Title)
+
+
+class SubBase(Base):
+    sub_id = models.IntegerField(primary_key=True)
+
+
+class GrandParent(models.Model):
+    first_name = models.CharField(max_length=80)
+    last_name = models.CharField(max_length=80)
+    email = models.EmailField(unique=True)
+    place = models.ForeignKey(Place, models.CASCADE, null=True, related_name="+")
+
+    class Meta:
+        # Ordering used by test_inherited_ordering_pk_desc.
+        ordering = ["-pk"]
+        unique_together = ("first_name", "last_name")
+
+
+class Parent(GrandParent):
+    pass
+
+
+class Child(Parent):
+    pass
+
+
+class GrandChild(Child):
+    pass
+
+
+class CommonAncestor(models.Model):
+    id = models.IntegerField(primary_key=True, default=1)
+
+
+class FirstParent(CommonAncestor):
+    first_ancestor = models.OneToOneField(
+        CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
+    )
+
+
+class SecondParent(CommonAncestor):
+    second_ancestor = models.OneToOneField(
+        CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
+    )
+
+
+class CommonChild(FirstParent, SecondParent):
+    pass

testbed/django__django/tests/model_inheritance/test_abstract_inheritance.py

@@ -0,0 +1,449 @@
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
+from django.contrib.contenttypes.models import ContentType
+from django.core.checks import Error
+from django.core.exceptions import FieldDoesNotExist, FieldError
+from django.db import models
+from django.test import SimpleTestCase
+from django.test.utils import isolate_apps
+
+
+@isolate_apps("model_inheritance")
+class AbstractInheritanceTests(SimpleTestCase):
+    def test_single_parent(self):
+        class AbstractBase(models.Model):
+            name = models.CharField(max_length=30)
+
+            class Meta:
+                abstract = True
+
+        class AbstractDescendant(AbstractBase):
+            name = models.CharField(max_length=50)
+
+            class Meta:
+                abstract = True
+
+        class DerivedChild(AbstractBase):
+            name = models.CharField(max_length=50)
+
+        class DerivedGrandChild(AbstractDescendant):
+            pass
+
+        self.assertEqual(AbstractDescendant._meta.get_field("name").max_length, 50)
+        self.assertEqual(DerivedChild._meta.get_field("name").max_length, 50)
+        self.assertEqual(DerivedGrandChild._meta.get_field("name").max_length, 50)
+
+    def test_multiple_inheritance_allows_inherited_field(self):
+        """
+        Single layer multiple inheritance is as expected, deriving the
+        inherited field from the first base.
+        """
+
+        class ParentA(models.Model):
+            name = models.CharField(max_length=255)
+
+            class Meta:
+                abstract = True
+
+        class ParentB(models.Model):
+            name = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        class Child(ParentA, ParentB):
+            pass
+
+        self.assertEqual(Child.check(), [])
+        inherited_field = Child._meta.get_field("name")
+        self.assertIsInstance(inherited_field, models.CharField)
+        self.assertEqual(inherited_field.max_length, 255)
+
+    def test_diamond_shaped_multiple_inheritance_is_depth_first(self):
+        """
+        In contrast to standard Python MRO, resolution of inherited fields is
+        strictly depth-first, rather than breadth-first in diamond-shaped cases.
+
+        This is because a copy of the parent field descriptor is placed onto
+        the model class in ModelBase.__new__(), rather than the attribute
+        lookup going via bases. (It only **looks** like inheritance.)
+
+        Here, Child inherits name from Root, rather than ParentB.
+        """
+
+        class Root(models.Model):
+            name = models.CharField(max_length=255)
+
+            class Meta:
+                abstract = True
+
+        class ParentA(Root):
+            class Meta:
+                abstract = True
+
+        class ParentB(Root):
+            name = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        class Child(ParentA, ParentB):
+            pass
+
+        self.assertEqual(Child.check(), [])
+        inherited_field = Child._meta.get_field("name")
+        self.assertIsInstance(inherited_field, models.CharField)
+        self.assertEqual(inherited_field.max_length, 255)
+
+    def test_target_field_may_be_pushed_down(self):
+        """
+        Where the Child model needs to inherit a field from a different base
+        than that given by depth-first resolution, the target field can be
+        **pushed down** by being re-declared.
+        """
+
+        class Root(models.Model):
+            name = models.CharField(max_length=255)
+
+            class Meta:
+                abstract = True
+
+        class ParentA(Root):
+            class Meta:
+                abstract = True
+
+        class ParentB(Root):
+            name = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        class Child(ParentA, ParentB):
+            name = models.IntegerField()
+
+        self.assertEqual(Child.check(), [])
+        inherited_field = Child._meta.get_field("name")
+        self.assertIsInstance(inherited_field, models.IntegerField)
+
+    def test_multiple_inheritance_cannot_shadow_concrete_inherited_field(self):
+        class ConcreteParent(models.Model):
+            name = models.CharField(max_length=255)
+
+        class AbstractParent(models.Model):
+            name = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        class FirstChild(ConcreteParent, AbstractParent):
+            pass
+
+        class AnotherChild(AbstractParent, ConcreteParent):
+            pass
+
+        self.assertIsInstance(FirstChild._meta.get_field("name"), models.CharField)
+        self.assertEqual(
+            AnotherChild.check(),
+            [
+                Error(
+                    "The field 'name' clashes with the field 'name' "
+                    "from model 'model_inheritance.concreteparent'.",
+                    obj=AnotherChild._meta.get_field("name"),
+                    id="models.E006",
+                )
+            ],
+        )
+
+    def test_virtual_field(self):
+        class RelationModel(models.Model):
+            content_type = models.ForeignKey(ContentType, models.CASCADE)
+            object_id = models.PositiveIntegerField()
+            content_object = GenericForeignKey("content_type", "object_id")
+
+        class RelatedModelAbstract(models.Model):
+            field = GenericRelation(RelationModel)
+
+            class Meta:
+                abstract = True
+
+        class ModelAbstract(models.Model):
+            field = models.CharField(max_length=100)
+
+            class Meta:
+                abstract = True
+
+        class OverrideRelatedModelAbstract(RelatedModelAbstract):
+            field = models.CharField(max_length=100)
+
+        class ExtendModelAbstract(ModelAbstract):
+            field = GenericRelation(RelationModel)
+
+        self.assertIsInstance(
+            OverrideRelatedModelAbstract._meta.get_field("field"), models.CharField
+        )
+        self.assertIsInstance(
+            ExtendModelAbstract._meta.get_field("field"), GenericRelation
+        )
+
+    def test_cannot_override_indirect_abstract_field(self):
+        class AbstractBase(models.Model):
+            name = models.CharField(max_length=30)
+
+            class Meta:
+                abstract = True
+
+        class ConcreteDescendant(AbstractBase):
+            pass
+
+        msg = (
+            "Local field 'name' in class 'Descendant' clashes with field of "
+            "the same name from base class 'ConcreteDescendant'."
+        )
+        with self.assertRaisesMessage(FieldError, msg):
+
+            class Descendant(ConcreteDescendant):
+                name = models.IntegerField()
+
+    def test_override_field_with_attr(self):
+        class AbstractBase(models.Model):
+            first_name = models.CharField(max_length=50)
+            last_name = models.CharField(max_length=50)
+            middle_name = models.CharField(max_length=30)
+            full_name = models.CharField(max_length=150)
+
+            class Meta:
+                abstract = True
+
+        class Descendant(AbstractBase):
+            middle_name = None
+
+            def full_name(self):
+                return self.first_name + self.last_name
+
+        msg = "Descendant has no field named %r"
+        with self.assertRaisesMessage(FieldDoesNotExist, msg % "middle_name"):
+            Descendant._meta.get_field("middle_name")
+
+        with self.assertRaisesMessage(FieldDoesNotExist, msg % "full_name"):
+            Descendant._meta.get_field("full_name")
+
+    def test_overriding_field_removed_by_concrete_model(self):
+        class AbstractModel(models.Model):
+            foo = models.CharField(max_length=30)
+
+            class Meta:
+                abstract = True
+
+        class RemovedAbstractModelField(AbstractModel):
+            foo = None
+
+        class OverrideRemovedFieldByConcreteModel(RemovedAbstractModelField):
+            foo = models.CharField(max_length=50)
+
+        self.assertEqual(
+            OverrideRemovedFieldByConcreteModel._meta.get_field("foo").max_length, 50
+        )
+
+    def test_shadowed_fkey_id(self):
+        class Foo(models.Model):
+            pass
+
+        class AbstractBase(models.Model):
+            foo = models.ForeignKey(Foo, models.CASCADE)
+
+            class Meta:
+                abstract = True
+
+        class Descendant(AbstractBase):
+            foo_id = models.IntegerField()
+
+        self.assertEqual(
+            Descendant.check(),
+            [
+                Error(
+                    "The field 'foo_id' clashes with the field 'foo' "
+                    "from model 'model_inheritance.descendant'.",
+                    obj=Descendant._meta.get_field("foo_id"),
+                    id="models.E006",
+                )
+            ],
+        )
+
+    def test_shadow_related_name_when_set_to_none(self):
+        class AbstractBase(models.Model):
+            bar = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        class Foo(AbstractBase):
+            bar = None
+            foo = models.IntegerField()
+
+        class Bar(models.Model):
+            bar = models.ForeignKey(Foo, models.CASCADE, related_name="bar")
+
+        self.assertEqual(Bar.check(), [])
+
+    def test_reverse_foreign_key(self):
+        class AbstractBase(models.Model):
+            foo = models.CharField(max_length=100)
+
+            class Meta:
+                abstract = True
+
+        class Descendant(AbstractBase):
+            pass
+
+        class Foo(models.Model):
+            foo = models.ForeignKey(Descendant, models.CASCADE, related_name="foo")
+
+        self.assertEqual(
+            Foo._meta.get_field("foo").check(),
+            [
+                Error(
+                    "Reverse accessor 'Descendant.foo' for "
+                    "'model_inheritance.Foo.foo' clashes with field name "
+                    "'model_inheritance.Descendant.foo'.",
+                    hint=(
+                        "Rename field 'model_inheritance.Descendant.foo', or "
+                        "add/change a related_name argument to the definition "
+                        "for field 'model_inheritance.Foo.foo'."
+                    ),
+                    obj=Foo._meta.get_field("foo"),
+                    id="fields.E302",
+                ),
+                Error(
+                    "Reverse query name for 'model_inheritance.Foo.foo' "
+                    "clashes with field name "
+                    "'model_inheritance.Descendant.foo'.",
+                    hint=(
+                        "Rename field 'model_inheritance.Descendant.foo', or "
+                        "add/change a related_name argument to the definition "
+                        "for field 'model_inheritance.Foo.foo'."
+                    ),
+                    obj=Foo._meta.get_field("foo"),
+                    id="fields.E303",
+                ),
+            ],
+        )
+
+    def test_multi_inheritance_field_clashes(self):
+        class AbstractBase(models.Model):
+            name = models.CharField(max_length=30)
+
+            class Meta:
+                abstract = True
+
+        class ConcreteBase(AbstractBase):
+            pass
+
+        class AbstractDescendant(ConcreteBase):
+            class Meta:
+                abstract = True
+
+        class ConcreteDescendant(AbstractDescendant):
+            name = models.CharField(max_length=100)
+
+        self.assertEqual(
+            ConcreteDescendant.check(),
+            [
+                Error(
+                    "The field 'name' clashes with the field 'name' from "
+                    "model 'model_inheritance.concretebase'.",
+                    obj=ConcreteDescendant._meta.get_field("name"),
+                    id="models.E006",
+                )
+            ],
+        )
+
+    def test_override_one2one_relation_auto_field_clashes(self):
+        class ConcreteParent(models.Model):
+            name = models.CharField(max_length=255)
+
+        class AbstractParent(models.Model):
+            name = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        msg = (
+            "Auto-generated field 'concreteparent_ptr' in class 'Descendant' "
+            "for parent_link to base class 'ConcreteParent' clashes with "
+            "declared field of the same name."
+        )
+        with self.assertRaisesMessage(FieldError, msg):
+
+            class Descendant(ConcreteParent, AbstractParent):
+                concreteparent_ptr = models.CharField(max_length=30)
+
+    def test_abstract_model_with_regular_python_mixin_mro(self):
+        class AbstractModel(models.Model):
+            name = models.CharField(max_length=255)
+            age = models.IntegerField()
+
+            class Meta:
+                abstract = True
+
+        class Mixin:
+            age = None
+
+        class Mixin2:
+            age = 2
+
+        class DescendantMixin(Mixin):
+            pass
+
+        class ConcreteModel(models.Model):
+            foo = models.IntegerField()
+
+        class ConcreteModel2(ConcreteModel):
+            age = models.SmallIntegerField()
+
+        def fields(model):
+            if not hasattr(model, "_meta"):
+                return []
+            return [(f.name, f.__class__) for f in model._meta.get_fields()]
+
+        model_dict = {"__module__": "model_inheritance"}
+        model1 = type("Model1", (AbstractModel, Mixin), model_dict.copy())
+        model2 = type("Model2", (Mixin2, AbstractModel), model_dict.copy())
+        model3 = type("Model3", (DescendantMixin, AbstractModel), model_dict.copy())
+        model4 = type("Model4", (Mixin2, Mixin, AbstractModel), model_dict.copy())
+        model5 = type(
+            "Model5", (Mixin2, ConcreteModel2, Mixin, AbstractModel), model_dict.copy()
+        )
+
+        self.assertEqual(
+            fields(model1),
+            [
+                ("id", models.AutoField),
+                ("name", models.CharField),
+                ("age", models.IntegerField),
+            ],
+        )
+
+        self.assertEqual(
+            fields(model2), [("id", models.AutoField), ("name", models.CharField)]
+        )
+        self.assertEqual(getattr(model2, "age"), 2)
+
+        self.assertEqual(
+            fields(model3), [("id", models.AutoField), ("name", models.CharField)]
+        )
+
+        self.assertEqual(
+            fields(model4), [("id", models.AutoField), ("name", models.CharField)]
+        )
+        self.assertEqual(getattr(model4, "age"), 2)
+
+        self.assertEqual(
+            fields(model5),
+            [
+                ("id", models.AutoField),
+                ("foo", models.IntegerField),
+                ("concretemodel_ptr", models.OneToOneField),
+                ("age", models.SmallIntegerField),
+                ("concretemodel2_ptr", models.OneToOneField),
+                ("name", models.CharField),
+            ],
+        )

testbed/django__django/tests/model_inheritance/tests.py

@@ -0,0 +1,670 @@
+from operator import attrgetter
+
+from django.core.exceptions import FieldError, ValidationError
+from django.db import connection, models
+from django.db.models.query_utils import DeferredAttribute
+from django.test import SimpleTestCase, TestCase
+from django.test.utils import CaptureQueriesContext, isolate_apps
+
+from .models import (
+    Base,
+    Chef,
+    CommonChild,
+    CommonInfo,
+    CustomSupplier,
+    GrandChild,
+    GrandParent,
+    ItalianRestaurant,
+    ItalianRestaurantCommonParent,
+    MixinModel,
+    Parent,
+    ParkingLot,
+    Place,
+    Post,
+    Restaurant,
+    Student,
+    SubBase,
+    Supplier,
+    Title,
+    Worker,
+)
+
+
+class ModelInheritanceTests(TestCase):
+    def test_abstract(self):
+        # The Student and Worker models both have 'name' and 'age' fields on
+        # them and inherit the __str__() method, just as with normal Python
+        # subclassing. This is useful if you want to factor out common
+        # information for programming purposes, but still completely
+        # independent separate models at the database level.
+        w1 = Worker.objects.create(name="Fred", age=35, job="Quarry worker")
+        Worker.objects.create(name="Barney", age=34, job="Quarry worker")
+
+        s = Student.objects.create(name="Pebbles", age=5, school_class="1B")
+
+        self.assertEqual(str(w1), "Worker Fred")
+        self.assertEqual(str(s), "Student Pebbles")
+
+        # The children inherit the Meta class of their parents (if they don't
+        # specify their own).
+        self.assertSequenceEqual(
+            Worker.objects.values("name"),
+            [
+                {"name": "Barney"},
+                {"name": "Fred"},
+            ],
+        )
+
+        # Since Student does not subclass CommonInfo's Meta, it has the effect
+        # of completely overriding it. So ordering by name doesn't take place
+        # for Students.
+        self.assertEqual(Student._meta.ordering, [])
+
+        # However, the CommonInfo class cannot be used as a normal model (it
+        # doesn't exist as a model).
+        with self.assertRaisesMessage(
+            AttributeError, "'CommonInfo' has no attribute 'objects'"
+        ):
+            CommonInfo.objects.all()
+
+    def test_reverse_relation_for_different_hierarchy_tree(self):
+        # Even though p.supplier for a Place 'p' (a parent of a Supplier), a
+        # Restaurant object cannot access that reverse relation, since it's not
+        # part of the Place-Supplier Hierarchy.
+        self.assertSequenceEqual(Place.objects.filter(supplier__name="foo"), [])
+        msg = (
+            "Cannot resolve keyword 'supplier' into field. Choices are: "
+            "address, chef, chef_id, id, italianrestaurant, lot, name, "
+            "place_ptr, place_ptr_id, provider, rating, serves_hot_dogs, serves_pizza"
+        )
+        with self.assertRaisesMessage(FieldError, msg):
+            Restaurant.objects.filter(supplier__name="foo")
+
+    def test_model_with_distinct_accessors(self):
+        # The Post model has distinct accessors for the Comment and Link models.
+        post = Post.objects.create(title="Lorem Ipsum")
+        post.attached_comment_set.create(content="Save $ on V1agr@", is_spam=True)
+        post.attached_link_set.create(
+            content="The web framework for perfections with deadlines.",
+            url="http://www.djangoproject.com/",
+        )
+
+        # The Post model doesn't have an attribute called
+        # 'attached_%(class)s_set'.
+        msg = "'Post' object has no attribute 'attached_%(class)s_set'"
+        with self.assertRaisesMessage(AttributeError, msg):
+            getattr(post, "attached_%(class)s_set")
+
+    def test_model_with_distinct_related_query_name(self):
+        self.assertSequenceEqual(
+            Post.objects.filter(attached_model_inheritance_comments__is_spam=True), []
+        )
+
+        # The Post model doesn't have a related query accessor based on
+        # related_name (attached_comment_set).
+        msg = "Cannot resolve keyword 'attached_comment_set' into field."
+        with self.assertRaisesMessage(FieldError, msg):
+            Post.objects.filter(attached_comment_set__is_spam=True)
+
+    def test_meta_fields_and_ordering(self):
+        # Make sure Restaurant and ItalianRestaurant have the right fields in
+        # the right order.
+        self.assertEqual(
+            [f.name for f in Restaurant._meta.fields],
+            [
+                "id",
+                "name",
+                "address",
+                "place_ptr",
+                "rating",
+                "serves_hot_dogs",
+                "serves_pizza",
+                "chef",
+            ],
+        )
+        self.assertEqual(
+            [f.name for f in ItalianRestaurant._meta.fields],
+            [
+                "id",
+                "name",
+                "address",
+                "place_ptr",
+                "rating",
+                "serves_hot_dogs",
+                "serves_pizza",
+                "chef",
+                "restaurant_ptr",
+                "serves_gnocchi",
+            ],
+        )
+        self.assertEqual(Restaurant._meta.ordering, ["-rating"])
+
+    def test_custompk_m2m(self):
+        b = Base.objects.create()
+        b.titles.add(Title.objects.create(title="foof"))
+        s = SubBase.objects.create(sub_id=b.id)
+        b = Base.objects.get(pk=s.id)
+        self.assertNotEqual(b.pk, s.pk)
+        # Low-level test for related_val
+        self.assertEqual(s.titles.related_val, (s.id,))
+        # Higher level test for correct query values (title foof not
+        # accidentally found).
+        self.assertSequenceEqual(s.titles.all(), [])
+
+    def test_create_diamond_mti_default_pk(self):
+        # 1 INSERT for each base.
+        with self.assertNumQueries(4):
+            common_child = CommonChild.objects.create()
+        # 3 SELECTs for the parents, 1 UPDATE for the child.
+        with self.assertNumQueries(4):
+            common_child.save()
+
+    def test_create_diamond_mti_common_parent(self):
+        with self.assertNumQueries(4):
+            italian_restaurant_child = ItalianRestaurantCommonParent.objects.create(
+                name="Ristorante Miron",
+                address="1234 W. Ash",
+            )
+
+        self.assertEqual(
+            italian_restaurant_child.italianrestaurant_ptr.place_ptr,
+            italian_restaurant_child.place_ptr_two,
+        )
+        self.assertEqual(
+            italian_restaurant_child.italianrestaurant_ptr.restaurant_ptr,
+            italian_restaurant_child.restaurant_ptr,
+        )
+        self.assertEqual(
+            italian_restaurant_child.restaurant_ptr.place_ptr,
+            italian_restaurant_child.place_ptr_two,
+        )
+        self.assertEqual(italian_restaurant_child.name, "Ristorante Miron")
+        self.assertEqual(italian_restaurant_child.address, "1234 W. Ash")
+
+    def test_update_parent_filtering(self):
+        """
+        Updating a field of a model subclass doesn't issue an UPDATE
+        query constrained by an inner query (#10399).
+        """
+        supplier = Supplier.objects.create(
+            name="Central market",
+            address="610 some street",
+        )
+        # Capture the expected query in a database agnostic way
+        with CaptureQueriesContext(connection) as captured_queries:
+            Place.objects.filter(pk=supplier.pk).update(name=supplier.name)
+        expected_sql = captured_queries[0]["sql"]
+        # Capture the queries executed when a subclassed model instance is saved.
+        with CaptureQueriesContext(connection) as captured_queries:
+            supplier.save(update_fields=("name",))
+        for query in captured_queries:
+            sql = query["sql"]
+            if "UPDATE" in sql:
+                self.assertEqual(expected_sql, sql)
+
+    def test_create_child_no_update(self):
+        """Creating a child with non-abstract parents only issues INSERTs."""
+
+        def a():
+            GrandChild.objects.create(
+                email="grand_parent@example.com",
+                first_name="grand",
+                last_name="parent",
+            )
+
+        def b():
+            GrandChild().save()
+
+        for i, test in enumerate([a, b]):
+            with self.subTest(i=i), self.assertNumQueries(4), CaptureQueriesContext(
+                connection
+            ) as queries:
+                test()
+                for query in queries:
+                    sql = query["sql"]
+                    self.assertIn("INSERT INTO", sql, sql)
+
+    def test_create_copy_with_inherited_m2m(self):
+        restaurant = Restaurant.objects.create()
+        supplier = CustomSupplier.objects.create(
+            name="Central market", address="944 W. Fullerton"
+        )
+        supplier.customers.set([restaurant])
+        old_customers = supplier.customers.all()
+        supplier.pk = None
+        supplier.id = None
+        supplier._state.adding = True
+        supplier.save()
+        supplier.customers.set(old_customers)
+        supplier = Supplier.objects.get(pk=supplier.pk)
+        self.assertCountEqual(supplier.customers.all(), old_customers)
+        self.assertSequenceEqual(supplier.customers.all(), [restaurant])
+
+    def test_eq(self):
+        # Equality doesn't transfer in multitable inheritance.
+        self.assertNotEqual(Place(id=1), Restaurant(id=1))
+        self.assertNotEqual(Restaurant(id=1), Place(id=1))
+
+    def test_mixin_init(self):
+        m = MixinModel()
+        self.assertEqual(m.other_attr, 1)
+
+    @isolate_apps("model_inheritance")
+    def test_abstract_parent_link(self):
+        class A(models.Model):
+            pass
+
+        class B(A):
+            a = models.OneToOneField("A", parent_link=True, on_delete=models.CASCADE)
+
+            class Meta:
+                abstract = True
+
+        class C(B):
+            pass
+
+        self.assertIs(C._meta.parents[A], C._meta.get_field("a"))
+
+    @isolate_apps("model_inheritance")
+    def test_init_subclass(self):
+        saved_kwargs = {}
+
+        class A(models.Model):
+            def __init_subclass__(cls, **kwargs):
+                super().__init_subclass__()
+                saved_kwargs.update(kwargs)
+
+        kwargs = {"x": 1, "y": 2, "z": 3}
+
+        class B(A, **kwargs):
+            pass
+
+        self.assertEqual(saved_kwargs, kwargs)
+
+    @isolate_apps("model_inheritance")
+    def test_set_name(self):
+        class ClassAttr:
+            called = None
+
+            def __set_name__(self_, owner, name):
+                self.assertIsNone(self_.called)
+                self_.called = (owner, name)
+
+        class A(models.Model):
+            attr = ClassAttr()
+
+        self.assertEqual(A.attr.called, (A, "attr"))
+
+    def test_inherited_ordering_pk_desc(self):
+        p1 = Parent.objects.create(first_name="Joe", email="joe@email.com")
+        p2 = Parent.objects.create(first_name="Jon", email="jon@email.com")
+        expected_order_by_sql = "ORDER BY %s.%s DESC" % (
+            connection.ops.quote_name(Parent._meta.db_table),
+            connection.ops.quote_name(Parent._meta.get_field("grandparent_ptr").column),
+        )
+        qs = Parent.objects.all()
+        self.assertSequenceEqual(qs, [p2, p1])
+        self.assertIn(expected_order_by_sql, str(qs.query))
+
+    def test_queryset_class_getitem(self):
+        self.assertIs(models.QuerySet[Post], models.QuerySet)
+        self.assertIs(models.QuerySet[Post, Post], models.QuerySet)
+        self.assertIs(models.QuerySet[Post, int, str], models.QuerySet)
+
+    def test_shadow_parent_attribute_with_field(self):
+        class ScalarParent(models.Model):
+            foo = 1
+
+        class ScalarOverride(ScalarParent):
+            foo = models.IntegerField()
+
+        self.assertEqual(type(ScalarOverride.foo), DeferredAttribute)
+
+    def test_shadow_parent_property_with_field(self):
+        class PropertyParent(models.Model):
+            @property
+            def foo(self):
+                pass
+
+        class PropertyOverride(PropertyParent):
+            foo = models.IntegerField()
+
+        self.assertEqual(type(PropertyOverride.foo), DeferredAttribute)
+
+    def test_shadow_parent_method_with_field(self):
+        class MethodParent(models.Model):
+            def foo(self):
+                pass
+
+        class MethodOverride(MethodParent):
+            foo = models.IntegerField()
+
+        self.assertEqual(type(MethodOverride.foo), DeferredAttribute)
+
+
+class ModelInheritanceDataTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.restaurant = Restaurant.objects.create(
+            name="Demon Dogs",
+            address="944 W. Fullerton",
+            serves_hot_dogs=True,
+            serves_pizza=False,
+            rating=2,
+        )
+
+        chef = Chef.objects.create(name="Albert")
+        cls.italian_restaurant = ItalianRestaurant.objects.create(
+            name="Ristorante Miron",
+            address="1234 W. Ash",
+            serves_hot_dogs=False,
+            serves_pizza=False,
+            serves_gnocchi=True,
+            rating=4,
+            chef=chef,
+        )
+
+    def test_filter_inherited_model(self):
+        self.assertQuerySetEqual(
+            ItalianRestaurant.objects.filter(address="1234 W. Ash"),
+            [
+                "Ristorante Miron",
+            ],
+            attrgetter("name"),
+        )
+
+    def test_update_inherited_model(self):
+        self.italian_restaurant.address = "1234 W. Elm"
+        self.italian_restaurant.save()
+        self.assertQuerySetEqual(
+            ItalianRestaurant.objects.filter(address="1234 W. Elm"),
+            [
+                "Ristorante Miron",
+            ],
+            attrgetter("name"),
+        )
+
+    def test_parent_fields_available_for_filtering_in_child_model(self):
+        # Parent fields can be used directly in filters on the child model.
+        self.assertQuerySetEqual(
+            Restaurant.objects.filter(name="Demon Dogs"),
+            [
+                "Demon Dogs",
+            ],
+            attrgetter("name"),
+        )
+        self.assertQuerySetEqual(
+            ItalianRestaurant.objects.filter(address="1234 W. Ash"),
+            [
+                "Ristorante Miron",
+            ],
+            attrgetter("name"),
+        )
+
+    def test_filter_on_parent_returns_object_of_parent_type(self):
+        # Filters against the parent model return objects of the parent's type.
+        p = Place.objects.get(name="Demon Dogs")
+        self.assertIs(type(p), Place)
+
+    def test_parent_child_one_to_one_link(self):
+        # Since the parent and child are linked by an automatically created
+        # OneToOneField, you can get from the parent to the child by using the
+        # child's name.
+        self.assertEqual(
+            Place.objects.get(name="Demon Dogs").restaurant,
+            Restaurant.objects.get(name="Demon Dogs"),
+        )
+        self.assertEqual(
+            Place.objects.get(name="Ristorante Miron").restaurant.italianrestaurant,
+            ItalianRestaurant.objects.get(name="Ristorante Miron"),
+        )
+        self.assertEqual(
+            Restaurant.objects.get(name="Ristorante Miron").italianrestaurant,
+            ItalianRestaurant.objects.get(name="Ristorante Miron"),
+        )
+
+    def test_parent_child_one_to_one_link_on_nonrelated_objects(self):
+        # This won't work because the Demon Dogs restaurant is not an Italian
+        # restaurant.
+        with self.assertRaises(ItalianRestaurant.DoesNotExist):
+            Place.objects.get(name="Demon Dogs").restaurant.italianrestaurant
+
+    def test_inherited_does_not_exist_exception(self):
+        # An ItalianRestaurant which does not exist is also a Place which does
+        # not exist.
+        with self.assertRaises(Place.DoesNotExist):
+            ItalianRestaurant.objects.get(name="The Noodle Void")
+
+    def test_inherited_multiple_objects_returned_exception(self):
+        # MultipleObjectsReturned is also inherited.
+        with self.assertRaises(Place.MultipleObjectsReturned):
+            Restaurant.objects.get()
+
+    def test_related_objects_for_inherited_models(self):
+        # Related objects work just as they normally do.
+        s1 = Supplier.objects.create(name="Joe's Chickens", address="123 Sesame St")
+        s1.customers.set([self.restaurant, self.italian_restaurant])
+        s2 = Supplier.objects.create(name="Luigi's Pasta", address="456 Sesame St")
+        s2.customers.set([self.italian_restaurant])
+
+        # This won't work because the Place we select is not a Restaurant (it's
+        # a Supplier).
+        p = Place.objects.get(name="Joe's Chickens")
+        with self.assertRaises(Restaurant.DoesNotExist):
+            p.restaurant
+
+        self.assertEqual(p.supplier, s1)
+        self.assertQuerySetEqual(
+            self.italian_restaurant.provider.order_by("-name"),
+            ["Luigi's Pasta", "Joe's Chickens"],
+            attrgetter("name"),
+        )
+        self.assertQuerySetEqual(
+            Restaurant.objects.filter(provider__name__contains="Chickens"),
+            [
+                "Ristorante Miron",
+                "Demon Dogs",
+            ],
+            attrgetter("name"),
+        )
+        self.assertQuerySetEqual(
+            ItalianRestaurant.objects.filter(provider__name__contains="Chickens"),
+            [
+                "Ristorante Miron",
+            ],
+            attrgetter("name"),
+        )
+
+        ParkingLot.objects.create(name="Main St", address="111 Main St", main_site=s1)
+        ParkingLot.objects.create(
+            name="Well Lit", address="124 Sesame St", main_site=self.italian_restaurant
+        )
+
+        self.assertEqual(
+            Restaurant.objects.get(lot__name="Well Lit").name, "Ristorante Miron"
+        )
+
+    def test_update_works_on_parent_and_child_models_at_once(self):
+        # The update() command can update fields in parent and child classes at
+        # once (although it executed multiple SQL queries to do so).
+        rows = Restaurant.objects.filter(
+            serves_hot_dogs=True, name__contains="D"
+        ).update(name="Demon Puppies", serves_hot_dogs=False)
+        self.assertEqual(rows, 1)
+
+        r1 = Restaurant.objects.get(pk=self.restaurant.pk)
+        self.assertFalse(r1.serves_hot_dogs)
+        self.assertEqual(r1.name, "Demon Puppies")
+
+    def test_values_works_on_parent_model_fields(self):
+        # The values() command also works on fields from parent models.
+        self.assertSequenceEqual(
+            ItalianRestaurant.objects.values("name", "rating"),
+            [
+                {"rating": 4, "name": "Ristorante Miron"},
+            ],
+        )
+
+    def test_select_related_works_on_parent_model_fields(self):
+        # select_related works with fields from the parent object as if they
+        # were a normal part of the model.
+        self.assertNumQueries(2, lambda: ItalianRestaurant.objects.all()[0].chef)
+        self.assertNumQueries(
+            1, lambda: ItalianRestaurant.objects.select_related("chef")[0].chef
+        )
+
+    def test_select_related_defer(self):
+        """
+        #23370 - Should be able to defer child fields when using
+        select_related() from parent to child.
+        """
+        qs = (
+            Restaurant.objects.select_related("italianrestaurant")
+            .defer("italianrestaurant__serves_gnocchi")
+            .order_by("rating")
+        )
+
+        # The field was actually deferred
+        with self.assertNumQueries(2):
+            objs = list(qs.all())
+            self.assertTrue(objs[1].italianrestaurant.serves_gnocchi)
+
+        # Model fields where assigned correct values
+        self.assertEqual(qs[0].name, "Demon Dogs")
+        self.assertEqual(qs[0].rating, 2)
+        self.assertEqual(qs[1].italianrestaurant.name, "Ristorante Miron")
+        self.assertEqual(qs[1].italianrestaurant.rating, 4)
+
+    def test_parent_cache_reuse(self):
+        place = Place.objects.create()
+        GrandChild.objects.create(place=place)
+        grand_parent = GrandParent.objects.latest("pk")
+        with self.assertNumQueries(1):
+            self.assertEqual(grand_parent.place, place)
+        parent = grand_parent.parent
+        with self.assertNumQueries(0):
+            self.assertEqual(parent.place, place)
+        child = parent.child
+        with self.assertNumQueries(0):
+            self.assertEqual(child.place, place)
+        grandchild = child.grandchild
+        with self.assertNumQueries(0):
+            self.assertEqual(grandchild.place, place)
+
+    def test_update_query_counts(self):
+        """
+        Update queries do not generate unnecessary queries (#18304).
+        """
+        with self.assertNumQueries(3):
+            self.italian_restaurant.save()
+
+    def test_filter_inherited_on_null(self):
+        # Refs #12567
+        Supplier.objects.create(
+            name="Central market",
+            address="610 some street",
+        )
+        self.assertQuerySetEqual(
+            Place.objects.filter(supplier__isnull=False),
+            [
+                "Central market",
+            ],
+            attrgetter("name"),
+        )
+        self.assertQuerySetEqual(
+            Place.objects.filter(supplier__isnull=True).order_by("name"),
+            [
+                "Demon Dogs",
+                "Ristorante Miron",
+            ],
+            attrgetter("name"),
+        )
+
+    def test_exclude_inherited_on_null(self):
+        # Refs #12567
+        Supplier.objects.create(
+            name="Central market",
+            address="610 some street",
+        )
+        self.assertQuerySetEqual(
+            Place.objects.exclude(supplier__isnull=False).order_by("name"),
+            [
+                "Demon Dogs",
+                "Ristorante Miron",
+            ],
+            attrgetter("name"),
+        )
+        self.assertQuerySetEqual(
+            Place.objects.exclude(supplier__isnull=True),
+            [
+                "Central market",
+            ],
+            attrgetter("name"),
+        )
+
+
+@isolate_apps("model_inheritance", "model_inheritance.tests")
+class InheritanceSameModelNameTests(SimpleTestCase):
+    def test_abstract_fk_related_name(self):
+        related_name = "%(app_label)s_%(class)s_references"
+
+        class Referenced(models.Model):
+            class Meta:
+                app_label = "model_inheritance"
+
+        class AbstractReferent(models.Model):
+            reference = models.ForeignKey(
+                Referenced, models.CASCADE, related_name=related_name
+            )
+
+            class Meta:
+                app_label = "model_inheritance"
+                abstract = True
+
+        class Referent(AbstractReferent):
+            class Meta:
+                app_label = "model_inheritance"
+
+        LocalReferent = Referent
+
+        class Referent(AbstractReferent):
+            class Meta:
+                app_label = "tests"
+
+        ForeignReferent = Referent
+
+        self.assertFalse(hasattr(Referenced, related_name))
+        self.assertIs(
+            Referenced.model_inheritance_referent_references.field.model, LocalReferent
+        )
+        self.assertIs(Referenced.tests_referent_references.field.model, ForeignReferent)
+
+
+class InheritanceUniqueTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.grand_parent = GrandParent.objects.create(
+            email="grand_parent@example.com",
+            first_name="grand",
+            last_name="parent",
+        )
+
+    def test_unique(self):
+        grand_child = GrandChild(
+            email=self.grand_parent.email,
+            first_name="grand",
+            last_name="child",
+        )
+        msg = "Grand parent with this Email already exists."
+        with self.assertRaisesMessage(ValidationError, msg):
+            grand_child.validate_unique()
+
+    def test_unique_together(self):
+        grand_child = GrandChild(
+            email="grand_child@example.com",
+            first_name=self.grand_parent.first_name,
+            last_name=self.grand_parent.last_name,
+        )
+        msg = "Grand parent with this First name and Last name already exists."
+        with self.assertRaisesMessage(ValidationError, msg):
+            grand_child.validate_unique()

testbed/django__django/tests/model_inheritance_regress/models.py

@@ -0,0 +1,207 @@
+import datetime
+
+from django.db import models
+
+
+class Place(models.Model):
+    name = models.CharField(max_length=50)
+    address = models.CharField(max_length=80)
+
+    class Meta:
+        ordering = ("name",)
+
+
+class Restaurant(Place):
+    serves_hot_dogs = models.BooleanField(default=False)
+    serves_pizza = models.BooleanField(default=False)
+
+
+class ItalianRestaurant(Restaurant):
+    serves_gnocchi = models.BooleanField(default=False)
+
+
+class ParkingLot(Place):
+    # An explicit link to the parent (we can control the attribute name).
+    parent = models.OneToOneField(
+        Place, models.CASCADE, primary_key=True, parent_link=True
+    )
+    capacity = models.IntegerField()
+
+
+class ParkingLot3(Place):
+    # The parent_link connector need not be the pk on the model.
+    primary_key = models.AutoField(primary_key=True)
+    parent = models.OneToOneField(Place, models.CASCADE, parent_link=True)
+
+
+class ParkingLot4(models.Model):
+    # Test parent_link connector can be discovered in abstract classes.
+    parent = models.OneToOneField(Place, models.CASCADE, parent_link=True)
+
+    class Meta:
+        abstract = True
+
+
+class ParkingLot4A(ParkingLot4, Place):
+    pass
+
+
+class ParkingLot4B(Place, ParkingLot4):
+    pass
+
+
+class Supplier(models.Model):
+    name = models.CharField(max_length=50)
+    restaurant = models.ForeignKey(Restaurant, models.CASCADE)
+
+
+class Wholesaler(Supplier):
+    retailer = models.ForeignKey(
+        Supplier, models.CASCADE, related_name="wholesale_supplier"
+    )
+
+
+class Parent(models.Model):
+    created = models.DateTimeField(default=datetime.datetime.now)
+
+
+class Child(Parent):
+    name = models.CharField(max_length=10)
+
+
+class SelfRefParent(models.Model):
+    parent_data = models.IntegerField()
+    self_data = models.ForeignKey("self", models.SET_NULL, null=True)
+
+
+class SelfRefChild(SelfRefParent):
+    child_data = models.IntegerField()
+
+
+class Article(models.Model):
+    headline = models.CharField(max_length=100)
+    pub_date = models.DateTimeField()
+
+    class Meta:
+        ordering = ("-pub_date", "headline")
+
+
+class ArticleWithAuthor(Article):
+    author = models.CharField(max_length=100)
+
+
+class M2MBase(models.Model):
+    articles = models.ManyToManyField(Article)
+
+
+class M2MChild(M2MBase):
+    name = models.CharField(max_length=50)
+
+
+class Evaluation(Article):
+    quality = models.IntegerField()
+
+    class Meta:
+        abstract = True
+
+
+class QualityControl(Evaluation):
+    assignee = models.CharField(max_length=50)
+
+
+class BaseM(models.Model):
+    base_name = models.CharField(max_length=100)
+
+
+class DerivedM(BaseM):
+    customPK = models.IntegerField(primary_key=True)
+    derived_name = models.CharField(max_length=100)
+
+
+class AuditBase(models.Model):
+    planned_date = models.DateField()
+
+    class Meta:
+        abstract = True
+        verbose_name_plural = "Audits"
+
+
+class CertificationAudit(AuditBase):
+    class Meta(AuditBase.Meta):
+        abstract = True
+
+
+class InternalCertificationAudit(CertificationAudit):
+    auditing_dept = models.CharField(max_length=20)
+
+
+# Abstract classes don't get m2m tables autocreated.
+class Person(models.Model):
+    name = models.CharField(max_length=100)
+
+    class Meta:
+        ordering = ("name",)
+
+
+class AbstractEvent(models.Model):
+    name = models.CharField(max_length=100)
+    attendees = models.ManyToManyField(Person, related_name="%(class)s_set")
+
+    class Meta:
+        abstract = True
+        ordering = ("name",)
+
+
+class BirthdayParty(AbstractEvent):
+    pass
+
+
+class BachelorParty(AbstractEvent):
+    pass
+
+
+class MessyBachelorParty(BachelorParty):
+    pass
+
+
+# Check concrete -> abstract -> concrete inheritance
+class SearchableLocation(models.Model):
+    keywords = models.CharField(max_length=255)
+
+
+class Station(SearchableLocation):
+    name = models.CharField(max_length=128)
+
+    class Meta:
+        abstract = True
+
+
+class BusStation(Station):
+    inbound = models.BooleanField(default=False)
+
+
+class TrainStation(Station):
+    zone = models.IntegerField()
+
+
+class User(models.Model):
+    username = models.CharField(max_length=30, unique=True)
+
+
+class Profile(User):
+    profile_id = models.AutoField(primary_key=True)
+    extra = models.CharField(max_length=30, blank=True)
+
+
+# Check concrete + concrete -> concrete -> concrete
+class Politician(models.Model):
+    politician_id = models.AutoField(primary_key=True)
+    title = models.CharField(max_length=50)
+
+
+class Congressman(Person, Politician):
+    state = models.CharField(max_length=2)
+
+
+class Senator(Congressman):
+    pass

testbed/django__django/tests/model_inheritance_regress/tests.py

@@ -0,0 +1,676 @@
+"""
+Regression tests for Model inheritance behavior.
+"""
+import datetime
+from operator import attrgetter
+from unittest import expectedFailure
+
+from django import forms
+from django.test import TestCase
+
+from .models import (
+    ArticleWithAuthor,
+    BachelorParty,
+    BirthdayParty,
+    BusStation,
+    Child,
+    Congressman,
+    DerivedM,
+    InternalCertificationAudit,
+    ItalianRestaurant,
+    M2MChild,
+    MessyBachelorParty,
+    ParkingLot,
+    ParkingLot3,
+    ParkingLot4A,
+    ParkingLot4B,
+    Person,
+    Place,
+    Politician,
+    Profile,
+    QualityControl,
+    Restaurant,
+    SelfRefChild,
+    SelfRefParent,
+    Senator,
+    Supplier,
+    TrainStation,
+    User,
+    Wholesaler,
+)
+
+
+class ModelInheritanceTest(TestCase):
+    def test_model_inheritance(self):
+        # Regression for #7350, #7202
+        # When you create a Parent object with a specific reference to an
+        # existent child instance, saving the Parent doesn't duplicate the
+        # child. This behavior is only activated during a raw save - it is
+        # mostly relevant to deserialization, but any sort of CORBA style
+        # 'narrow()' API would require a similar approach.
+
+        # Create a child-parent-grandparent chain
+        place1 = Place(name="Guido's House of Pasta", address="944 W. Fullerton")
+        place1.save_base(raw=True)
+        restaurant = Restaurant(
+            place_ptr=place1,
+            serves_hot_dogs=True,
+            serves_pizza=False,
+        )
+        restaurant.save_base(raw=True)
+        italian_restaurant = ItalianRestaurant(
+            restaurant_ptr=restaurant, serves_gnocchi=True
+        )
+        italian_restaurant.save_base(raw=True)
+
+        # Create a child-parent chain with an explicit parent link
+        place2 = Place(name="Main St", address="111 Main St")
+        place2.save_base(raw=True)
+        park = ParkingLot(parent=place2, capacity=100)
+        park.save_base(raw=True)
+
+        # No extra parent objects have been created.
+        places = list(Place.objects.all())
+        self.assertEqual(places, [place1, place2])
+
+        dicts = list(Restaurant.objects.values("name", "serves_hot_dogs"))
+        self.assertEqual(
+            dicts, [{"name": "Guido's House of Pasta", "serves_hot_dogs": True}]
+        )
+
+        dicts = list(
+            ItalianRestaurant.objects.values(
+                "name", "serves_hot_dogs", "serves_gnocchi"
+            )
+        )
+        self.assertEqual(
+            dicts,
+            [
+                {
+                    "name": "Guido's House of Pasta",
+                    "serves_gnocchi": True,
+                    "serves_hot_dogs": True,
+                }
+            ],
+        )
+
+        dicts = list(ParkingLot.objects.values("name", "capacity"))
+        self.assertEqual(
+            dicts,
+            [
+                {
+                    "capacity": 100,
+                    "name": "Main St",
+                }
+            ],
+        )
+
+        # You can also update objects when using a raw save.
+        place1.name = "Guido's All New House of Pasta"
+        place1.save_base(raw=True)
+
+        restaurant.serves_hot_dogs = False
+        restaurant.save_base(raw=True)
+
+        italian_restaurant.serves_gnocchi = False
+        italian_restaurant.save_base(raw=True)
+
+        place2.name = "Derelict lot"
+        place2.save_base(raw=True)
+
+        park.capacity = 50
+        park.save_base(raw=True)
+
+        # No extra parent objects after an update, either.
+        places = list(Place.objects.all())
+        self.assertEqual(places, [place2, place1])
+        self.assertEqual(places[0].name, "Derelict lot")
+        self.assertEqual(places[1].name, "Guido's All New House of Pasta")
+
+        dicts = list(Restaurant.objects.values("name", "serves_hot_dogs"))
+        self.assertEqual(
+            dicts,
+            [
+                {
+                    "name": "Guido's All New House of Pasta",
+                    "serves_hot_dogs": False,
+                }
+            ],
+        )
+
+        dicts = list(
+            ItalianRestaurant.objects.values(
+                "name", "serves_hot_dogs", "serves_gnocchi"
+            )
+        )
+        self.assertEqual(
+            dicts,
+            [
+                {
+                    "name": "Guido's All New House of Pasta",
+                    "serves_gnocchi": False,
+                    "serves_hot_dogs": False,
+                }
+            ],
+        )
+
+        dicts = list(ParkingLot.objects.values("name", "capacity"))
+        self.assertEqual(
+            dicts,
+            [
+                {
+                    "capacity": 50,
+                    "name": "Derelict lot",
+                }
+            ],
+        )
+
+        # If you try to raw_save a parent attribute onto a child object,
+        # the attribute will be ignored.
+
+        italian_restaurant.name = "Lorenzo's Pasta Hut"
+        italian_restaurant.save_base(raw=True)
+
+        # Note that the name has not changed
+        # - name is an attribute of Place, not ItalianRestaurant
+        dicts = list(
+            ItalianRestaurant.objects.values(
+                "name", "serves_hot_dogs", "serves_gnocchi"
+            )
+        )
+        self.assertEqual(
+            dicts,
+            [
+                {
+                    "name": "Guido's All New House of Pasta",
+                    "serves_gnocchi": False,
+                    "serves_hot_dogs": False,
+                }
+            ],
+        )
+
+    def test_issue_7105(self):
+        # Regressions tests for #7105: dates() queries should be able to use
+        # fields from the parent model as easily as the child.
+        Child.objects.create(
+            name="child", created=datetime.datetime(2008, 6, 26, 17, 0, 0)
+        )
+        datetimes = list(Child.objects.datetimes("created", "month"))
+        self.assertEqual(datetimes, [datetime.datetime(2008, 6, 1, 0, 0)])
+
+    def test_issue_7276(self):
+        # Regression test for #7276: calling delete() on a model with
+        # multi-table inheritance should delete the associated rows from any
+        # ancestor tables, as well as any descendent objects.
+        place1 = Place(name="Guido's House of Pasta", address="944 W. Fullerton")
+        place1.save_base(raw=True)
+        restaurant = Restaurant(
+            place_ptr=place1,
+            serves_hot_dogs=True,
+            serves_pizza=False,
+        )
+        restaurant.save_base(raw=True)
+        italian_restaurant = ItalianRestaurant(
+            restaurant_ptr=restaurant, serves_gnocchi=True
+        )
+        italian_restaurant.save_base(raw=True)
+
+        ident = ItalianRestaurant.objects.all()[0].id
+        self.assertEqual(Place.objects.get(pk=ident), place1)
+        Restaurant.objects.create(
+            name="a",
+            address="xx",
+            serves_hot_dogs=True,
+            serves_pizza=False,
+        )
+
+        # This should delete both Restaurants, plus the related places, plus
+        # the ItalianRestaurant.
+        Restaurant.objects.all().delete()
+
+        with self.assertRaises(Place.DoesNotExist):
+            Place.objects.get(pk=ident)
+        with self.assertRaises(ItalianRestaurant.DoesNotExist):
+            ItalianRestaurant.objects.get(pk=ident)
+
+    def test_issue_6755(self):
+        """
+        Regression test for #6755
+        """
+        r = Restaurant(serves_pizza=False, serves_hot_dogs=False)
+        r.save()
+        self.assertEqual(r.id, r.place_ptr_id)
+        orig_id = r.id
+        r = Restaurant(place_ptr_id=orig_id, serves_pizza=True, serves_hot_dogs=False)
+        r.save()
+        self.assertEqual(r.id, orig_id)
+        self.assertEqual(r.id, r.place_ptr_id)
+
+    def test_issue_11764(self):
+        """
+        Regression test for #11764
+        """
+        wholesalers = list(Wholesaler.objects.select_related())
+        self.assertEqual(wholesalers, [])
+
+    def test_issue_7853(self):
+        """
+        Regression test for #7853
+        If the parent class has a self-referential link, make sure that any
+        updates to that link via the child update the right table.
+        """
+        obj = SelfRefChild.objects.create(child_data=37, parent_data=42)
+        obj.delete()
+
+    def test_get_next_previous_by_date(self):
+        """
+        Regression tests for #8076
+        get_(next/previous)_by_date should work
+        """
+        c1 = ArticleWithAuthor(
+            headline="ArticleWithAuthor 1",
+            author="Person 1",
+            pub_date=datetime.datetime(2005, 8, 1, 3, 0),
+        )
+        c1.save()
+        c2 = ArticleWithAuthor(
+            headline="ArticleWithAuthor 2",
+            author="Person 2",
+            pub_date=datetime.datetime(2005, 8, 1, 10, 0),
+        )
+        c2.save()
+        c3 = ArticleWithAuthor(
+            headline="ArticleWithAuthor 3",
+            author="Person 3",
+            pub_date=datetime.datetime(2005, 8, 2),
+        )
+        c3.save()
+
+        self.assertEqual(c1.get_next_by_pub_date(), c2)
+        self.assertEqual(c2.get_next_by_pub_date(), c3)
+        with self.assertRaises(ArticleWithAuthor.DoesNotExist):
+            c3.get_next_by_pub_date()
+        self.assertEqual(c3.get_previous_by_pub_date(), c2)
+        self.assertEqual(c2.get_previous_by_pub_date(), c1)
+        with self.assertRaises(ArticleWithAuthor.DoesNotExist):
+            c1.get_previous_by_pub_date()
+
+    def test_inherited_fields(self):
+        """
+        Regression test for #8825 and #9390
+        Make sure all inherited fields (esp. m2m fields, in this case) appear
+        on the child class.
+        """
+        m2mchildren = list(M2MChild.objects.filter(articles__isnull=False))
+        self.assertEqual(m2mchildren, [])
+
+        # Ordering should not include any database column more than once (this
+        # is most likely to occur naturally with model inheritance, so we
+        # check it here). Regression test for #9390. This necessarily pokes at
+        # the SQL string for the query, since the duplicate problems are only
+        # apparent at that late stage.
+        qs = ArticleWithAuthor.objects.order_by("pub_date", "pk")
+        sql = qs.query.get_compiler(qs.db).as_sql()[0]
+        fragment = sql[sql.find("ORDER BY") :]
+        pos = fragment.find("pub_date")
+        self.assertEqual(fragment.find("pub_date", pos + 1), -1)
+
+    def test_queryset_update_on_parent_model(self):
+        """
+        Regression test for #10362
+        It is possible to call update() and only change a field in
+        an ancestor model.
+        """
+        article = ArticleWithAuthor.objects.create(
+            author="fred",
+            headline="Hey there!",
+            pub_date=datetime.datetime(2009, 3, 1, 8, 0, 0),
+        )
+        update = ArticleWithAuthor.objects.filter(author="fred").update(
+            headline="Oh, no!"
+        )
+        self.assertEqual(update, 1)
+        update = ArticleWithAuthor.objects.filter(pk=article.pk).update(
+            headline="Oh, no!"
+        )
+        self.assertEqual(update, 1)
+
+        derivedm1 = DerivedM.objects.create(
+            customPK=44,
+            base_name="b1",
+            derived_name="d1",
+        )
+        self.assertEqual(derivedm1.customPK, 44)
+        self.assertEqual(derivedm1.base_name, "b1")
+        self.assertEqual(derivedm1.derived_name, "d1")
+        derivedms = list(DerivedM.objects.all())
+        self.assertEqual(derivedms, [derivedm1])
+
+    def test_use_explicit_o2o_to_parent_as_pk(self):
+        """
+        The connector from child to parent need not be the pk on the child.
+        """
+        self.assertEqual(ParkingLot3._meta.pk.name, "primary_key")
+        # the child->parent link
+        self.assertEqual(ParkingLot3._meta.get_ancestor_link(Place).name, "parent")
+
+    def test_use_explicit_o2o_to_parent_from_abstract_model(self):
+        self.assertEqual(ParkingLot4A._meta.pk.name, "parent")
+        ParkingLot4A.objects.create(
+            name="Parking4A",
+            address="21 Jump Street",
+        )
+
+        self.assertEqual(ParkingLot4B._meta.pk.name, "parent")
+        ParkingLot4A.objects.create(
+            name="Parking4B",
+            address="21 Jump Street",
+        )
+
+    def test_all_fields_from_abstract_base_class(self):
+        """
+        Regression tests for #7588
+        """
+        # All fields from an ABC, including those inherited non-abstractly
+        # should be available on child classes (#7588). Creating this instance
+        # should work without error.
+        QualityControl.objects.create(
+            headline="Problems in Django",
+            pub_date=datetime.datetime.now(),
+            quality=10,
+            assignee="adrian",
+        )
+
+    def test_abstract_base_class_m2m_relation_inheritance(self):
+        # many-to-many relations defined on an abstract base class are
+        # correctly inherited (and created) on the child class.
+        p1 = Person.objects.create(name="Alice")
+        p2 = Person.objects.create(name="Bob")
+        p3 = Person.objects.create(name="Carol")
+        p4 = Person.objects.create(name="Dave")
+
+        birthday = BirthdayParty.objects.create(name="Birthday party for Alice")
+        birthday.attendees.set([p1, p3])
+
+        bachelor = BachelorParty.objects.create(name="Bachelor party for Bob")
+        bachelor.attendees.set([p2, p4])
+
+        parties = list(p1.birthdayparty_set.all())
+        self.assertEqual(parties, [birthday])
+
+        parties = list(p1.bachelorparty_set.all())
+        self.assertEqual(parties, [])
+
+        parties = list(p2.bachelorparty_set.all())
+        self.assertEqual(parties, [bachelor])
+
+        # A subclass of a subclass of an abstract model doesn't get its own
+        # accessor.
+        self.assertFalse(hasattr(p2, "messybachelorparty_set"))
+
+        # ... but it does inherit the m2m from its parent
+        messy = MessyBachelorParty.objects.create(name="Bachelor party for Dave")
+        messy.attendees.set([p4])
+        messy_parent = messy.bachelorparty_ptr
+
+        parties = list(p4.bachelorparty_set.all())
+        self.assertEqual(parties, [bachelor, messy_parent])
+
+    def test_abstract_verbose_name_plural_inheritance(self):
+        """
+        verbose_name_plural correctly inherited from ABC if inheritance chain
+        includes an abstract model.
+        """
+        # Regression test for #11369: verbose_name_plural should be inherited
+        # from an ABC even when there are one or more intermediate
+        # abstract models in the inheritance chain, for consistency with
+        # verbose_name.
+        self.assertEqual(InternalCertificationAudit._meta.verbose_name_plural, "Audits")
+
+    def test_inherited_nullable_exclude(self):
+        obj = SelfRefChild.objects.create(child_data=37, parent_data=42)
+        self.assertQuerySetEqual(
+            SelfRefParent.objects.exclude(self_data=72), [obj.pk], attrgetter("pk")
+        )
+        self.assertQuerySetEqual(
+            SelfRefChild.objects.exclude(self_data=72), [obj.pk], attrgetter("pk")
+        )
+
+    def test_concrete_abstract_concrete_pk(self):
+        """
+        Primary key set correctly with concrete->abstract->concrete inheritance.
+        """
+        # Regression test for #13987: Primary key is incorrectly determined
+        # when more than one model has a concrete->abstract->concrete
+        # inheritance hierarchy.
+        self.assertEqual(
+            len(
+                [field for field in BusStation._meta.local_fields if field.primary_key]
+            ),
+            1,
+        )
+        self.assertEqual(
+            len(
+                [
+                    field
+                    for field in TrainStation._meta.local_fields
+                    if field.primary_key
+                ]
+            ),
+            1,
+        )
+        self.assertIs(BusStation._meta.pk.model, BusStation)
+        self.assertIs(TrainStation._meta.pk.model, TrainStation)
+
+    def test_inherited_unique_field_with_form(self):
+        """
+        A model which has different primary key for the parent model passes
+        unique field checking correctly (#17615).
+        """
+
+        class ProfileForm(forms.ModelForm):
+            class Meta:
+                model = Profile
+                fields = "__all__"
+
+        User.objects.create(username="user_only")
+        p = Profile.objects.create(username="user_with_profile")
+        form = ProfileForm(
+            {"username": "user_with_profile", "extra": "hello"}, instance=p
+        )
+        self.assertTrue(form.is_valid())
+
+    def test_inheritance_joins(self):
+        # Test for #17502 - check that filtering through two levels of
+        # inheritance chain doesn't generate extra joins.
+        qs = ItalianRestaurant.objects.all()
+        self.assertEqual(str(qs.query).count("JOIN"), 2)
+        qs = ItalianRestaurant.objects.filter(name="foo")
+        self.assertEqual(str(qs.query).count("JOIN"), 2)
+
+    @expectedFailure
+    def test_inheritance_values_joins(self):
+        # It would be nice (but not too important) to skip the middle join in
+        # this case. Skipping is possible as nothing from the middle model is
+        # used in the qs and top contains direct pointer to the bottom model.
+        qs = ItalianRestaurant.objects.values_list("serves_gnocchi").filter(name="foo")
+        self.assertEqual(str(qs.query).count("JOIN"), 1)
+
+    def test_issue_21554(self):
+        senator = Senator.objects.create(name="John Doe", title="X", state="Y")
+        senator = Senator.objects.get(pk=senator.pk)
+        self.assertEqual(senator.name, "John Doe")
+        self.assertEqual(senator.title, "X")
+        self.assertEqual(senator.state, "Y")
+
+    def test_inheritance_resolve_columns(self):
+        Restaurant.objects.create(
+            name="Bobs Cafe",
+            address="Somewhere",
+            serves_pizza=True,
+            serves_hot_dogs=True,
+        )
+        p = Place.objects.select_related("restaurant")[0]
+        self.assertIsInstance(p.restaurant.serves_pizza, bool)
+
+    def test_inheritance_select_related(self):
+        # Regression test for #7246
+        r1 = Restaurant.objects.create(
+            name="Nobu", serves_hot_dogs=True, serves_pizza=False
+        )
+        r2 = Restaurant.objects.create(
+            name="Craft", serves_hot_dogs=False, serves_pizza=True
+        )
+        Supplier.objects.create(name="John", restaurant=r1)
+        Supplier.objects.create(name="Jane", restaurant=r2)
+
+        self.assertQuerySetEqual(
+            Supplier.objects.order_by("name").select_related(),
+            [
+                "Jane",
+                "John",
+            ],
+            attrgetter("name"),
+        )
+
+        jane = Supplier.objects.order_by("name").select_related("restaurant")[0]
+        self.assertEqual(jane.restaurant.name, "Craft")
+
+    def test_filter_with_parent_fk(self):
+        r = Restaurant.objects.create()
+        s = Supplier.objects.create(restaurant=r)
+        # The mismatch between Restaurant and Place is intentional (#28175).
+        self.assertSequenceEqual(
+            Supplier.objects.filter(restaurant__in=Place.objects.all()), [s]
+        )
+
+    def test_ptr_accessor_assigns_state(self):
+        r = Restaurant.objects.create()
+        self.assertIs(r.place_ptr._state.adding, False)
+        self.assertEqual(r.place_ptr._state.db, "default")
+
+    def test_related_filtering_query_efficiency_ticket_15844(self):
+        r = Restaurant.objects.create(
+            name="Guido's House of Pasta",
+            address="944 W. Fullerton",
+            serves_hot_dogs=True,
+            serves_pizza=False,
+        )
+        s = Supplier.objects.create(restaurant=r)
+        with self.assertNumQueries(1):
+            self.assertSequenceEqual(Supplier.objects.filter(restaurant=r), [s])
+        with self.assertNumQueries(1):
+            self.assertSequenceEqual(r.supplier_set.all(), [s])
+
+    def test_queries_on_parent_access(self):
+        italian_restaurant = ItalianRestaurant.objects.create(
+            name="Guido's House of Pasta",
+            address="944 W. Fullerton",
+            serves_hot_dogs=True,
+            serves_pizza=False,
+            serves_gnocchi=True,
+        )
+
+        # No queries are made when accessing the parent objects.
+        italian_restaurant = ItalianRestaurant.objects.get(pk=italian_restaurant.pk)
+        with self.assertNumQueries(0):
+            restaurant = italian_restaurant.restaurant_ptr
+            self.assertEqual(restaurant.place_ptr.restaurant, restaurant)
+            self.assertEqual(restaurant.italianrestaurant, italian_restaurant)
+
+        # One query is made when accessing the parent objects when the instance
+        # is deferred.
+        italian_restaurant = ItalianRestaurant.objects.only("serves_gnocchi").get(
+            pk=italian_restaurant.pk
+        )
+        with self.assertNumQueries(1):
+            restaurant = italian_restaurant.restaurant_ptr
+            self.assertEqual(restaurant.place_ptr.restaurant, restaurant)
+            self.assertEqual(restaurant.italianrestaurant, italian_restaurant)
+
+        # No queries are made when accessing the parent objects when the
+        # instance has deferred a field not present in the parent table.
+        italian_restaurant = ItalianRestaurant.objects.defer("serves_gnocchi").get(
+            pk=italian_restaurant.pk
+        )
+        with self.assertNumQueries(0):
+            restaurant = italian_restaurant.restaurant_ptr
+            self.assertEqual(restaurant.place_ptr.restaurant, restaurant)
+            self.assertEqual(restaurant.italianrestaurant, italian_restaurant)
+
+    def test_id_field_update_on_ancestor_change(self):
+        place1 = Place.objects.create(name="House of Pasta", address="944 Fullerton")
+        place2 = Place.objects.create(name="House of Pizza", address="954 Fullerton")
+        place3 = Place.objects.create(name="Burger house", address="964 Fullerton")
+        restaurant1 = Restaurant.objects.create(
+            place_ptr=place1,
+            serves_hot_dogs=True,
+            serves_pizza=False,
+        )
+        restaurant2 = Restaurant.objects.create(
+            place_ptr=place2,
+            serves_hot_dogs=True,
+            serves_pizza=False,
+        )
+
+        italian_restaurant = ItalianRestaurant.objects.create(
+            restaurant_ptr=restaurant1,
+            serves_gnocchi=True,
+        )
+        # Changing the parent of a restaurant changes the restaurant's ID & PK.
+        restaurant1.place_ptr = place3
+        self.assertEqual(restaurant1.pk, place3.pk)
+        self.assertEqual(restaurant1.id, place3.id)
+        self.assertEqual(restaurant1.pk, restaurant1.id)
+        restaurant1.place_ptr = None
+        self.assertIsNone(restaurant1.pk)
+        self.assertIsNone(restaurant1.id)
+        # Changing the parent of an italian restaurant changes the restaurant's
+        # ID & PK.
+        italian_restaurant.restaurant_ptr = restaurant2
+        self.assertEqual(italian_restaurant.pk, restaurant2.pk)
+        self.assertEqual(italian_restaurant.id, restaurant2.id)
+        self.assertEqual(italian_restaurant.pk, italian_restaurant.id)
+        italian_restaurant.restaurant_ptr = None
+        self.assertIsNone(italian_restaurant.pk)
+        self.assertIsNone(italian_restaurant.id)
+
+    def test_create_new_instance_with_pk_equals_none(self):
+        p1 = Profile.objects.create(username="john")
+        p2 = User.objects.get(pk=p1.user_ptr_id).profile
+        # Create a new profile by setting pk = None.
+        p2.pk = None
+        p2.user_ptr_id = None
+        p2.username = "bill"
+        p2.save()
+        self.assertEqual(Profile.objects.count(), 2)
+        self.assertEqual(User.objects.get(pk=p1.user_ptr_id).username, "john")
+
+    def test_create_new_instance_with_pk_equals_none_multi_inheritance(self):
+        c1 = Congressman.objects.create(state="PA", name="John", title="senator 1")
+        c2 = Person.objects.get(pk=c1.pk).congressman
+        # Create a new congressman by setting pk = None.
+        c2.pk = None
+        c2.id = None
+        c2.politician_ptr_id = None
+        c2.name = "Bill"
+        c2.title = "senator 2"
+        c2.save()
+        self.assertEqual(Congressman.objects.count(), 2)
+        self.assertEqual(Person.objects.get(pk=c1.pk).name, "John")
+        self.assertEqual(
+            Politician.objects.get(pk=c1.politician_ptr_id).title,
+            "senator 1",
+        )
+
+    def test_mti_update_parent_through_child(self):
+        Politician.objects.create()
+        Congressman.objects.create()
+        Congressman.objects.update(title="senator 1")
+        self.assertEqual(Congressman.objects.get().title, "senator 1")
+
+    def test_mti_update_grand_parent_through_child(self):
+        Politician.objects.create()
+        Senator.objects.create()
+        Senator.objects.update(title="senator 1")
+        self.assertEqual(Senator.objects.get().title, "senator 1")

testbed/django__django/tests/model_meta/models.py

@@ -0,0 +1,183 @@
+from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+
+
+class Relation(models.Model):
+    pass
+
+
+class InstanceOnlyDescriptor:
+    def __get__(self, instance, cls=None):
+        if instance is None:
+            raise AttributeError("Instance only")
+        return 1
+
+
+class AbstractPerson(models.Model):
+    # DATA fields
+    data_abstract = models.CharField(max_length=10)
+    fk_abstract = models.ForeignKey(
+        Relation, models.CASCADE, related_name="fk_abstract_rel"
+    )
+
+    # M2M fields
+    m2m_abstract = models.ManyToManyField(Relation, related_name="m2m_abstract_rel")
+    friends_abstract = models.ManyToManyField("self", symmetrical=True)
+    following_abstract = models.ManyToManyField(
+        "self", related_name="followers_abstract", symmetrical=False
+    )
+
+    # VIRTUAL fields
+    data_not_concrete_abstract = models.ForeignObject(
+        Relation,
+        on_delete=models.CASCADE,
+        from_fields=["abstract_non_concrete_id"],
+        to_fields=["id"],
+        related_name="fo_abstract_rel",
+    )
+
+    # GFK fields
+    content_type_abstract = models.ForeignKey(
+        ContentType, models.CASCADE, related_name="+"
+    )
+    object_id_abstract = models.PositiveIntegerField()
+    content_object_abstract = GenericForeignKey(
+        "content_type_abstract", "object_id_abstract"
+    )
+
+    # GR fields
+    generic_relation_abstract = GenericRelation(Relation)
+
+    class Meta:
+        abstract = True
+
+    @property
+    def test_property(self):
+        return 1
+
+    test_instance_only_descriptor = InstanceOnlyDescriptor()
+
+
+class BasePerson(AbstractPerson):
+    # DATA fields
+    data_base = models.CharField(max_length=10)
+    fk_base = models.ForeignKey(Relation, models.CASCADE, related_name="fk_base_rel")
+
+    # M2M fields
+    m2m_base = models.ManyToManyField(Relation, related_name="m2m_base_rel")
+    friends_base = models.ManyToManyField("self", symmetrical=True)
+    following_base = models.ManyToManyField(
+        "self", related_name="followers_base", symmetrical=False
+    )
+
+    # VIRTUAL fields
+    data_not_concrete_base = models.ForeignObject(
+        Relation,
+        on_delete=models.CASCADE,
+        from_fields=["base_non_concrete_id"],
+        to_fields=["id"],
+        related_name="fo_base_rel",
+    )
+
+    # GFK fields
+    content_type_base = models.ForeignKey(ContentType, models.CASCADE, related_name="+")
+    object_id_base = models.PositiveIntegerField()
+    content_object_base = GenericForeignKey("content_type_base", "object_id_base")
+
+    # GR fields
+    generic_relation_base = GenericRelation(Relation)
+
+
+class Person(BasePerson):
+    # DATA fields
+    data_inherited = models.CharField(max_length=10)
+    fk_inherited = models.ForeignKey(
+        Relation, models.CASCADE, related_name="fk_concrete_rel"
+    )
+
+    # M2M Fields
+    m2m_inherited = models.ManyToManyField(Relation, related_name="m2m_concrete_rel")
+    friends_inherited = models.ManyToManyField("self", symmetrical=True)
+    following_inherited = models.ManyToManyField(
+        "self", related_name="followers_concrete", symmetrical=False
+    )
+
+    # VIRTUAL fields
+    data_not_concrete_inherited = models.ForeignObject(
+        Relation,
+        on_delete=models.CASCADE,
+        from_fields=["model_non_concrete_id"],
+        to_fields=["id"],
+        related_name="fo_concrete_rel",
+    )
+
+    # GFK fields
+    content_type_concrete = models.ForeignKey(
+        ContentType, models.CASCADE, related_name="+"
+    )
+    object_id_concrete = models.PositiveIntegerField()
+    content_object_concrete = GenericForeignKey(
+        "content_type_concrete", "object_id_concrete"
+    )
+
+    # GR fields
+    generic_relation_concrete = GenericRelation(Relation)
+
+
+class ProxyPerson(Person):
+    class Meta:
+        proxy = True
+
+
+class PersonThroughProxySubclass(ProxyPerson):
+    pass
+
+
+class Relating(models.Model):
+    # ForeignKey to BasePerson
+    baseperson = models.ForeignKey(
+        BasePerson, models.CASCADE, related_name="relating_baseperson"
+    )
+    baseperson_hidden = models.ForeignKey(BasePerson, models.CASCADE, related_name="+")
+
+    # ForeignKey to Person
+    person = models.ForeignKey(Person, models.CASCADE, related_name="relating_person")
+    person_hidden = models.ForeignKey(Person, models.CASCADE, related_name="+")
+
+    # ForeignKey to ProxyPerson
+    proxyperson = models.ForeignKey(
+        ProxyPerson, models.CASCADE, related_name="relating_proxyperson"
+    )
+    proxyperson_hidden = models.ForeignKey(
+        ProxyPerson, models.CASCADE, related_name="relating_proxyperson_hidden+"
+    )
+
+    # ManyToManyField to BasePerson
+    basepeople = models.ManyToManyField(BasePerson, related_name="relating_basepeople")
+    basepeople_hidden = models.ManyToManyField(BasePerson, related_name="+")
+
+    # ManyToManyField to Person
+    people = models.ManyToManyField(Person, related_name="relating_people")
+    people_hidden = models.ManyToManyField(Person, related_name="+")
+
+
+# ParentListTests models
+class CommonAncestor(models.Model):
+    pass
+
+
+class FirstParent(CommonAncestor):
+    first_ancestor = models.OneToOneField(
+        CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
+    )
+
+
+class SecondParent(CommonAncestor):
+    second_ancestor = models.OneToOneField(
+        CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
+    )
+
+
+class Child(FirstParent, SecondParent):
+    pass

testbed/django__django/tests/model_meta/results.py

@@ -0,0 +1,895 @@
+from .models import AbstractPerson, BasePerson, Person, ProxyPerson, Relating, Relation
+
+TEST_RESULTS = {
+    "get_all_field_names": {
+        Person: [
+            "baseperson_ptr",
+            "baseperson_ptr_id",
+            "content_type_abstract",
+            "content_type_abstract_id",
+            "content_type_base",
+            "content_type_base_id",
+            "content_type_concrete",
+            "content_type_concrete_id",
+            "data_abstract",
+            "data_base",
+            "data_inherited",
+            "data_not_concrete_abstract",
+            "data_not_concrete_base",
+            "data_not_concrete_inherited",
+            "fk_abstract",
+            "fk_abstract_id",
+            "fk_base",
+            "fk_base_id",
+            "fk_inherited",
+            "fk_inherited_id",
+            "followers_abstract",
+            "followers_base",
+            "followers_concrete",
+            "following_abstract",
+            "following_base",
+            "following_inherited",
+            "friends_abstract",
+            "friends_base",
+            "friends_inherited",
+            "generic_relation_abstract",
+            "generic_relation_base",
+            "generic_relation_concrete",
+            "id",
+            "m2m_abstract",
+            "m2m_base",
+            "m2m_inherited",
+            "object_id_abstract",
+            "object_id_base",
+            "object_id_concrete",
+            "relating_basepeople",
+            "relating_baseperson",
+            "relating_people",
+            "relating_person",
+        ],
+        BasePerson: [
+            "content_type_abstract",
+            "content_type_abstract_id",
+            "content_type_base",
+            "content_type_base_id",
+            "data_abstract",
+            "data_base",
+            "data_not_concrete_abstract",
+            "data_not_concrete_base",
+            "fk_abstract",
+            "fk_abstract_id",
+            "fk_base",
+            "fk_base_id",
+            "followers_abstract",
+            "followers_base",
+            "following_abstract",
+            "following_base",
+            "friends_abstract",
+            "friends_base",
+            "generic_relation_abstract",
+            "generic_relation_base",
+            "id",
+            "m2m_abstract",
+            "m2m_base",
+            "object_id_abstract",
+            "object_id_base",
+            "person",
+            "relating_basepeople",
+            "relating_baseperson",
+        ],
+        AbstractPerson: [
+            "content_type_abstract",
+            "content_type_abstract_id",
+            "data_abstract",
+            "data_not_concrete_abstract",
+            "fk_abstract",
+            "fk_abstract_id",
+            "following_abstract",
+            "friends_abstract",
+            "generic_relation_abstract",
+            "m2m_abstract",
+            "object_id_abstract",
+        ],
+        Relating: [
+            "basepeople",
+            "basepeople_hidden",
+            "baseperson",
+            "baseperson_hidden",
+            "baseperson_hidden_id",
+            "baseperson_id",
+            "id",
+            "people",
+            "people_hidden",
+            "person",
+            "person_hidden",
+            "person_hidden_id",
+            "person_id",
+            "proxyperson",
+            "proxyperson_hidden",
+            "proxyperson_hidden_id",
+            "proxyperson_id",
+        ],
+    },
+    "fields": {
+        Person: [
+            "id",
+            "data_abstract",
+            "fk_abstract_id",
+            "data_not_concrete_abstract",
+            "content_type_abstract_id",
+            "object_id_abstract",
+            "data_base",
+            "fk_base_id",
+            "data_not_concrete_base",
+            "content_type_base_id",
+            "object_id_base",
+            "baseperson_ptr_id",
+            "data_inherited",
+            "fk_inherited_id",
+            "data_not_concrete_inherited",
+            "content_type_concrete_id",
+            "object_id_concrete",
+        ],
+        BasePerson: [
+            "id",
+            "data_abstract",
+            "fk_abstract_id",
+            "data_not_concrete_abstract",
+            "content_type_abstract_id",
+            "object_id_abstract",
+            "data_base",
+            "fk_base_id",
+            "data_not_concrete_base",
+            "content_type_base_id",
+            "object_id_base",
+        ],
+        AbstractPerson: [
+            "data_abstract",
+            "fk_abstract_id",
+            "data_not_concrete_abstract",
+            "content_type_abstract_id",
+            "object_id_abstract",
+        ],
+        Relating: [
+            "id",
+            "baseperson_id",
+            "baseperson_hidden_id",
+            "person_id",
+            "person_hidden_id",
+            "proxyperson_id",
+            "proxyperson_hidden_id",
+        ],
+    },
+    "local_fields": {
+        Person: [
+            "baseperson_ptr_id",
+            "data_inherited",
+            "fk_inherited_id",
+            "data_not_concrete_inherited",
+            "content_type_concrete_id",
+            "object_id_concrete",
+        ],
+        BasePerson: [
+            "id",
+            "data_abstract",
+            "fk_abstract_id",
+            "data_not_concrete_abstract",
+            "content_type_abstract_id",
+            "object_id_abstract",
+            "data_base",
+            "fk_base_id",
+            "data_not_concrete_base",
+            "content_type_base_id",
+            "object_id_base",
+        ],
+        AbstractPerson: [
+            "data_abstract",
+            "fk_abstract_id",
+            "data_not_concrete_abstract",
+            "content_type_abstract_id",
+            "object_id_abstract",
+        ],
+        Relating: [
+            "id",
+            "baseperson_id",
+            "baseperson_hidden_id",
+            "person_id",
+            "person_hidden_id",
+            "proxyperson_id",
+            "proxyperson_hidden_id",
+        ],
+    },
+    "local_concrete_fields": {
+        Person: [
+            "baseperson_ptr_id",
+            "data_inherited",
+            "fk_inherited_id",
+            "content_type_concrete_id",
+            "object_id_concrete",
+        ],
+        BasePerson: [
+            "id",
+            "data_abstract",
+            "fk_abstract_id",
+            "content_type_abstract_id",
+            "object_id_abstract",
+            "data_base",
+            "fk_base_id",
+            "content_type_base_id",
+            "object_id_base",
+        ],
+        AbstractPerson: [
+            "data_abstract",
+            "fk_abstract_id",
+            "content_type_abstract_id",
+            "object_id_abstract",
+        ],
+        Relating: [
+            "id",
+            "baseperson_id",
+            "baseperson_hidden_id",
+            "person_id",
+            "person_hidden_id",
+            "proxyperson_id",
+            "proxyperson_hidden_id",
+        ],
+    },
+    "many_to_many": {
+        Person: [
+            "m2m_abstract",
+            "friends_abstract",
+            "following_abstract",
+            "m2m_base",
+            "friends_base",
+            "following_base",
+            "m2m_inherited",
+            "friends_inherited",
+            "following_inherited",
+        ],
+        BasePerson: [
+            "m2m_abstract",
+            "friends_abstract",
+            "following_abstract",
+            "m2m_base",
+            "friends_base",
+            "following_base",
+        ],
+        AbstractPerson: [
+            "m2m_abstract",
+            "friends_abstract",
+            "following_abstract",
+        ],
+        Relating: [
+            "basepeople",
+            "basepeople_hidden",
+            "people",
+            "people_hidden",
+        ],
+    },
+    "many_to_many_with_model": {
+        Person: [
+            BasePerson,
+            BasePerson,
+            BasePerson,
+            BasePerson,
+            BasePerson,
+            BasePerson,
+            None,
+            None,
+            None,
+        ],
+        BasePerson: [
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        ],
+        AbstractPerson: [
+            None,
+            None,
+            None,
+        ],
+        Relating: [
+            None,
+            None,
+            None,
+            None,
+        ],
+    },
+    "get_all_related_objects_with_model_legacy": {
+        Person: (
+            ("relating_baseperson", BasePerson),
+            ("relating_person", None),
+        ),
+        BasePerson: (
+            ("person", None),
+            ("relating_baseperson", None),
+        ),
+        Relation: (
+            ("fk_abstract_rel", None),
+            ("fo_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fo_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_hidden_local": {
+        Person: (
+            ("+", None),
+            ("_model_meta_relating_people_hidden_+", None),
+            ("Person_following_inherited+", None),
+            ("Person_following_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_m2m_inherited+", None),
+            ("Relating_people+", None),
+            ("Relating_people_hidden+", None),
+            ("followers_concrete", None),
+            ("friends_inherited_rel_+", None),
+            ("personthroughproxysubclass", None),
+            ("relating_people", None),
+            ("relating_person", None),
+            ("relating_proxyperson", None),
+            ("relating_proxyperson_hidden+", None),
+        ),
+        ProxyPerson: (
+            ("+", Person),
+            ("_model_meta_relating_people_hidden_+", Person),
+            ("Person_following_inherited+", Person),
+            ("Person_following_inherited+", Person),
+            ("Person_friends_inherited+", Person),
+            ("Person_friends_inherited+", Person),
+            ("Person_m2m_inherited+", Person),
+            ("Relating_people+", Person),
+            ("Relating_people_hidden+", Person),
+            ("followers_concrete", Person),
+            ("friends_inherited_rel_+", Person),
+            ("personthroughproxysubclass", Person),
+            ("relating_people", Person),
+            ("relating_person", Person),
+            ("relating_proxyperson", Person),
+            ("relating_proxyperson_hidden+", Person),
+        ),
+        BasePerson: (
+            ("+", None),
+            ("_model_meta_relating_basepeople_hidden_+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Relating_basepeople+", None),
+            ("Relating_basepeople_hidden+", None),
+            ("followers_abstract", None),
+            ("followers_base", None),
+            ("friends_abstract_rel_+", None),
+            ("friends_base_rel_+", None),
+            ("person", None),
+            ("relating_basepeople", None),
+            ("relating_baseperson", None),
+        ),
+        Relation: (
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Person_m2m_inherited+", None),
+            ("fk_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_abstract_rel", None),
+            ("fo_base_rel", None),
+            ("fo_concrete_rel", None),
+            ("m2m_abstract_rel", None),
+            ("m2m_base_rel", None),
+            ("m2m_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_hidden": {
+        Person: (
+            ("+", BasePerson),
+            ("+", None),
+            ("_model_meta_relating_basepeople_hidden_+", BasePerson),
+            ("_model_meta_relating_people_hidden_+", None),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_m2m_abstract+", BasePerson),
+            ("BasePerson_m2m_base+", BasePerson),
+            ("Person_following_inherited+", None),
+            ("Person_following_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_m2m_inherited+", None),
+            ("Relating_basepeople+", BasePerson),
+            ("Relating_basepeople_hidden+", BasePerson),
+            ("Relating_people+", None),
+            ("Relating_people_hidden+", None),
+            ("followers_abstract", BasePerson),
+            ("followers_base", BasePerson),
+            ("followers_concrete", None),
+            ("friends_abstract_rel_+", BasePerson),
+            ("friends_base_rel_+", BasePerson),
+            ("friends_inherited_rel_+", None),
+            ("personthroughproxysubclass", None),
+            ("relating_basepeople", BasePerson),
+            ("relating_baseperson", BasePerson),
+            ("relating_people", None),
+            ("relating_person", None),
+            ("relating_proxyperson", None),
+            ("relating_proxyperson_hidden+", None),
+        ),
+        ProxyPerson: (
+            ("+", BasePerson),
+            ("+", Person),
+            ("_model_meta_relating_basepeople_hidden_+", BasePerson),
+            ("_model_meta_relating_people_hidden_+", Person),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_m2m_abstract+", BasePerson),
+            ("BasePerson_m2m_base+", BasePerson),
+            ("Person_following_inherited+", Person),
+            ("Person_following_inherited+", Person),
+            ("Person_friends_inherited+", Person),
+            ("Person_friends_inherited+", Person),
+            ("Person_m2m_inherited+", Person),
+            ("Relating_basepeople+", BasePerson),
+            ("Relating_basepeople_hidden+", BasePerson),
+            ("Relating_people+", Person),
+            ("Relating_people_hidden+", Person),
+            ("followers_abstract", BasePerson),
+            ("followers_base", BasePerson),
+            ("followers_concrete", Person),
+            ("friends_abstract_rel_+", BasePerson),
+            ("friends_base_rel_+", BasePerson),
+            ("friends_inherited_rel_+", Person),
+            ("personthroughproxysubclass", Person),
+            ("relating_basepeople", BasePerson),
+            ("relating_baseperson", BasePerson),
+            ("relating_people", Person),
+            ("relating_person", Person),
+            ("relating_proxyperson", Person),
+            ("relating_proxyperson_hidden+", Person),
+        ),
+        BasePerson: (
+            ("+", None),
+            ("_model_meta_relating_basepeople_hidden_+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Relating_basepeople+", None),
+            ("Relating_basepeople_hidden+", None),
+            ("followers_abstract", None),
+            ("followers_base", None),
+            ("friends_abstract_rel_+", None),
+            ("friends_base_rel_+", None),
+            ("person", None),
+            ("relating_basepeople", None),
+            ("relating_baseperson", None),
+        ),
+        Relation: (
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Person_m2m_inherited+", None),
+            ("fk_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_abstract_rel", None),
+            ("fo_base_rel", None),
+            ("fo_concrete_rel", None),
+            ("m2m_abstract_rel", None),
+            ("m2m_base_rel", None),
+            ("m2m_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_local": {
+        Person: (
+            ("followers_concrete", None),
+            ("personthroughproxysubclass", None),
+            ("relating_person", None),
+            ("relating_people", None),
+            ("relating_proxyperson", None),
+        ),
+        ProxyPerson: (
+            ("followers_concrete", Person),
+            ("personthroughproxysubclass", Person),
+            ("relating_person", Person),
+            ("relating_people", Person),
+            ("relating_proxyperson", Person),
+        ),
+        BasePerson: (
+            ("followers_abstract", None),
+            ("followers_base", None),
+            ("person", None),
+            ("relating_baseperson", None),
+            ("relating_basepeople", None),
+        ),
+        Relation: (
+            ("fk_abstract_rel", None),
+            ("fo_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fo_base_rel", None),
+            ("m2m_abstract_rel", None),
+            ("m2m_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_concrete_rel", None),
+            ("m2m_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model": {
+        Person: (
+            ("followers_abstract", BasePerson),
+            ("followers_base", BasePerson),
+            ("relating_baseperson", BasePerson),
+            ("relating_basepeople", BasePerson),
+            ("followers_concrete", None),
+            ("personthroughproxysubclass", None),
+            ("relating_person", None),
+            ("relating_people", None),
+            ("relating_proxyperson", None),
+        ),
+        ProxyPerson: (
+            ("followers_abstract", BasePerson),
+            ("followers_base", BasePerson),
+            ("relating_baseperson", BasePerson),
+            ("relating_basepeople", BasePerson),
+            ("followers_concrete", Person),
+            ("personthroughproxysubclass", Person),
+            ("relating_person", Person),
+            ("relating_people", Person),
+            ("relating_proxyperson", Person),
+        ),
+        BasePerson: (
+            ("followers_abstract", None),
+            ("followers_base", None),
+            ("person", None),
+            ("relating_baseperson", None),
+            ("relating_basepeople", None),
+        ),
+        Relation: (
+            ("fk_abstract_rel", None),
+            ("fo_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fo_base_rel", None),
+            ("m2m_abstract_rel", None),
+            ("m2m_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_concrete_rel", None),
+            ("m2m_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_local_legacy": {
+        Person: (("relating_person", None),),
+        BasePerson: (("person", None), ("relating_baseperson", None)),
+        Relation: (
+            ("fk_abstract_rel", None),
+            ("fo_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fo_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_hidden_legacy": {
+        BasePerson: (
+            ("+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Relating_basepeople+", None),
+            ("Relating_basepeople_hidden+", None),
+            ("person", None),
+            ("relating_baseperson", None),
+        ),
+        Person: (
+            ("+", BasePerson),
+            ("+", None),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_m2m_abstract+", BasePerson),
+            ("BasePerson_m2m_base+", BasePerson),
+            ("Person_following_inherited+", None),
+            ("Person_following_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_m2m_inherited+", None),
+            ("Relating_basepeople+", BasePerson),
+            ("Relating_basepeople_hidden+", BasePerson),
+            ("Relating_people+", None),
+            ("Relating_people_hidden+", None),
+            ("relating_baseperson", BasePerson),
+            ("relating_person", None),
+        ),
+        Relation: (
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Person_m2m_inherited+", None),
+            ("fk_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_abstract_rel", None),
+            ("fo_base_rel", None),
+            ("fo_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_hidden_local_legacy": {
+        BasePerson: (
+            ("+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Relating_basepeople+", None),
+            ("Relating_basepeople_hidden+", None),
+            ("person", None),
+            ("relating_baseperson", None),
+        ),
+        Person: (
+            ("+", None),
+            ("Person_following_inherited+", None),
+            ("Person_following_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_m2m_inherited+", None),
+            ("Relating_people+", None),
+            ("Relating_people_hidden+", None),
+            ("relating_person", None),
+        ),
+        Relation: (
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Person_m2m_inherited+", None),
+            ("fk_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_abstract_rel", None),
+            ("fo_base_rel", None),
+            ("fo_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_proxy_legacy": {
+        BasePerson: (
+            ("person", None),
+            ("relating_baseperson", None),
+        ),
+        Person: (
+            ("relating_baseperson", BasePerson),
+            ("relating_person", None),
+            ("relating_proxyperson", None),
+        ),
+        Relation: (
+            ("fk_abstract_rel", None),
+            ("fo_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fo_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_concrete_rel", None),
+        ),
+    },
+    "get_all_related_objects_with_model_proxy_hidden_legacy": {
+        BasePerson: (
+            ("+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_abstract+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_following_base+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_abstract+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_friends_base+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Relating_basepeople+", None),
+            ("Relating_basepeople_hidden+", None),
+            ("person", None),
+            ("relating_baseperson", None),
+        ),
+        Person: (
+            ("+", BasePerson),
+            ("+", None),
+            ("+", None),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_abstract+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_following_base+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_abstract+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_friends_base+", BasePerson),
+            ("BasePerson_m2m_abstract+", BasePerson),
+            ("BasePerson_m2m_base+", BasePerson),
+            ("Person_following_inherited+", None),
+            ("Person_following_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_friends_inherited+", None),
+            ("Person_m2m_inherited+", None),
+            ("Relating_basepeople+", BasePerson),
+            ("Relating_basepeople_hidden+", BasePerson),
+            ("Relating_people+", None),
+            ("Relating_people_hidden+", None),
+            ("relating_baseperson", BasePerson),
+            ("relating_person", None),
+            ("relating_proxyperson", None),
+        ),
+        Relation: (
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("+", None),
+            ("BasePerson_m2m_abstract+", None),
+            ("BasePerson_m2m_base+", None),
+            ("Person_m2m_inherited+", None),
+            ("fk_abstract_rel", None),
+            ("fk_base_rel", None),
+            ("fk_concrete_rel", None),
+            ("fo_abstract_rel", None),
+            ("fo_base_rel", None),
+            ("fo_concrete_rel", None),
+        ),
+    },
+    "get_all_related_many_to_many_with_model_legacy": {
+        BasePerson: (
+            ("friends_abstract_rel_+", None),
+            ("followers_abstract", None),
+            ("friends_base_rel_+", None),
+            ("followers_base", None),
+            ("relating_basepeople", None),
+            ("_model_meta_relating_basepeople_hidden_+", None),
+        ),
+        Person: (
+            ("friends_abstract_rel_+", BasePerson),
+            ("followers_abstract", BasePerson),
+            ("friends_base_rel_+", BasePerson),
+            ("followers_base", BasePerson),
+            ("relating_basepeople", BasePerson),
+            ("_model_meta_relating_basepeople_hidden_+", BasePerson),
+            ("friends_inherited_rel_+", None),
+            ("followers_concrete", None),
+            ("relating_people", None),
+            ("_relating_people_hidden_+", None),
+        ),
+        Relation: (
+            ("m2m_abstract_rel", None),
+            ("m2m_base_rel", None),
+            ("m2m_concrete_rel", None),
+        ),
+    },
+    "get_all_related_many_to_many_local_legacy": {
+        BasePerson: [
+            "friends_abstract_rel_+",
+            "followers_abstract",
+            "friends_base_rel_+",
+            "followers_base",
+            "relating_basepeople",
+            "_model_meta_relating_basepeople_hidden_+",
+        ],
+        Person: [
+            "friends_inherited_rel_+",
+            "followers_concrete",
+            "relating_people",
+            "_relating_people_hidden_+",
+        ],
+        Relation: [
+            "m2m_abstract_rel",
+            "m2m_base_rel",
+            "m2m_concrete_rel",
+        ],
+    },
+    "private_fields": {
+        AbstractPerson: [
+            "generic_relation_abstract",
+            "content_object_abstract",
+        ],
+        BasePerson: [
+            "generic_relation_base",
+            "content_object_base",
+            "generic_relation_abstract",
+            "content_object_abstract",
+        ],
+        Person: [
+            "content_object_concrete",
+            "generic_relation_concrete",
+            "generic_relation_base",
+            "content_object_base",
+            "generic_relation_abstract",
+            "content_object_abstract",
+        ],
+    },
+    "labels": {
+        AbstractPerson: "model_meta.AbstractPerson",
+        BasePerson: "model_meta.BasePerson",
+        Person: "model_meta.Person",
+        Relating: "model_meta.Relating",
+    },
+    "lower_labels": {
+        AbstractPerson: "model_meta.abstractperson",
+        BasePerson: "model_meta.baseperson",
+        Person: "model_meta.person",
+        Relating: "model_meta.relating",
+    },
+}