YOYSTRO

Doğrulama verileri: bağımsız değerlendirme raporları ve üretilen değişiklikler

Yoystro tam ürün çalıştırmasının elli görevi için SWE-bench bağımsız değerlendirme raporlarından okunan sonuçlar ve üretilen değişikliklerin tamamı. Bu ek yalnız ana ürün çalıştırmasını kapsar; hafıza deneyi dalları ve yeniden çalıştırmalar buraya girmez.

Ek B. Bağımsız değerlendirme raporları

Aşağıdaki tablo elli görevin her biri için bağımsız değerlendirmenin sonucunu ve test sonuçlarını taşır. FAIL_TO_PASS, değişikliğin geçirmesi gereken testlerdir; PASS_TO_PASS, değişikliğin bozmaması gereken testlerdir. Değişiklik boyutu ve dosya sayısı çalıştırma defterinden okunur.

Ek C. Üretilen değişiklikler

Aşağıda elli görevin üretilen değişiklikleri olduğu gibi verilmiştir. Her başlığın altındaki satır bağımsız değerlendirmenin o görev için verdiği özet sonuçtur.

diff --git a/astropy/coordinates/builtin_frames/__init__.py b/astropy/coordinates/builtin_frames/__init__.py
index 6fd688c285..17b524478e 100644
--- a/astropy/coordinates/builtin_frames/__init__.py
+++ b/astropy/coordinates/builtin_frames/__init__.py
@@ -48,6 +48,7 @@ from . import supergalactic_transforms
 from . import icrs_cirs_transforms
 from . import cirs_observed_transforms
 from . import icrs_observed_transforms
+from . import itrs_observed_transforms
 from . import intermediate_rotation_transforms
 from . import ecliptic_transforms
 
diff --git a/astropy/coordinates/builtin_frames/intermediate_rotation_transforms.py b/astropy/coordinates/builtin_frames/intermediate_rotation_transforms.py
index a15248c38d..3d6e7b770f 100644
--- a/astropy/coordinates/builtin_frames/intermediate_rotation_transforms.py
+++ b/astropy/coordinates/builtin_frames/intermediate_rotation_transforms.py
@@ -146,9 +146,9 @@ def tete_to_gcrs(tete_coo, gcrs_frame):
 
 @frame_transform_graph.transform(FunctionTransformWithFiniteDifference, TETE, ITRS)
 def tete_to_itrs(tete_coo, itrs_frame):
-    # first get us to TETE at the target obstime, and geocentric position
+    # first get us to TETE at the target obstime, and location (no-op if same)
     tete_coo2 = tete_coo.transform_to(TETE(obstime=itrs_frame.obstime,
-                                           location=EARTH_CENTER))
+                                           location=itrs_frame.location))
 
     # now get the pmatrix
     pmat = tete_to_itrs_mat(itrs_frame.obstime)
@@ -161,9 +161,9 @@ def itrs_to_tete(itrs_coo, tete_frame):
     # compute the pmatrix, and then multiply by its transpose
     pmat = tete_to_itrs_mat(itrs_coo.obstime)
     newrepr = itrs_coo.cartesian.transform(matrix_transpose(pmat))
-    tete = TETE(newrepr, obstime=itrs_coo.obstime)
+    tete = TETE(newrepr, obstime=itrs_coo.obstime, location=itrs_coo.location)
 
-    # now do any needed offsets (no-op if same obstime)
+    # now do any needed offsets (no-op if same obstime and location)
     return tete.transform_to(tete_frame)
 
 
@@ -196,9 +196,9 @@ def cirs_to_gcrs(cirs_coo, gcrs_frame):
 
 @frame_transform_graph.transform(FunctionTransformWithFiniteDifference, CIRS, ITRS)
 def cirs_to_itrs(cirs_coo, itrs_frame):
-    # first get us to geocentric CIRS at the target obstime
+    # first get us to CIRS at the target obstime, and location (no-op if same)
     cirs_coo2 = cirs_coo.transform_to(CIRS(obstime=itrs_frame.obstime,
-                                           location=EARTH_CENTER))
+                                           location=itrs_frame.location))
 
     # now get the pmatrix
     pmat = cirs_to_itrs_mat(itrs_frame.obstime)
@@ -211,9 +211,9 @@ def itrs_to_cirs(itrs_coo, cirs_frame):
     # compute the pmatrix, and then multiply by its transpose
     pmat = cirs_to_itrs_mat(itrs_coo.obstime)
     newrepr = itrs_coo.cartesian.transform(matrix_transpose(pmat))
-    cirs = CIRS(newrepr, obstime=itrs_coo.obstime)
+    cirs = CIRS(newrepr, obstime=itrs_coo.obstime, location=itrs_coo.location)
 
-    # now do any needed offsets (no-op if same obstime)
+    # now do any needed offsets (no-op if same obstime and location)
     return cirs.transform_to(cirs_frame)
 
 
diff --git a/astropy/coordinates/builtin_frames/itrs.py b/astropy/coordinates/builtin_frames/itrs.py
index e121ec9064..d8fe32d3b9 100644
--- a/astropy/coordinates/builtin_frames/itrs.py
+++ b/astropy/coordinates/builtin_frames/itrs.py
@@ -3,26 +3,68 @@
 from astropy.utils.decorators import format_doc
 from astropy.coordinates.representation import CartesianRepresentation, CartesianDifferential
 from astropy.coordinates.baseframe import BaseCoordinateFrame, base_doc
-from astropy.coordinates.attributes import TimeAttribute
-from .utils import DEFAULT_OBSTIME
+from astropy.coordinates.attributes import (TimeAttribute,
+                                            EarthLocationAttribute)
+from .utils import DEFAULT_OBSTIME, EARTH_CENTER
 
 __all__ = ['ITRS']
 
+doc_footer = """
+    Other parameters
+    ----------------
+    obstime : `~astropy.time.Time`
+        The time at which the observation is taken.  Used for determining the
+        position of the Earth and its precession.
+    location : `~astropy.coordinates.EarthLocation`
+        The location on the Earth.  This can be specified either as an
+        `~astropy.coordinates.EarthLocation` object or as anything that can be
+        transformed to an `~astropy.coordinates.ITRS` frame. The default is the
+        centre of the Earth.
+"""
 
-@format_doc(base_doc, components="", footer="")
+
+@format_doc(base_doc, components="", footer=doc_footer)
 class ITRS(BaseCoordinateFrame):
     """
     A coordinate or frame in the International Terrestrial Reference System
     (ITRS).  This is approximately a geocentric system, although strictly it is
-    defined by a series of reference locations near the surface of the Earth.
+    defined by a series of reference locations near the surface of the Earth (the ITRF).
     For more background on the ITRS, see the references provided in the
     :ref:`astropy:astropy-coordinates-seealso` section of the documentation.
+
+    This frame also includes frames that are defined *relative* to the center of the Earth,
+    but that are offset (in both position and velocity) from the center of the Earth. You
+    may see such non-geocentric coordinates referred to as "topocentric".
+
+    Topocentric ITRS frames are convenient for observations of near Earth objects where
+    stellar aberration is not included. One can merely subtract the observing site's
+    EarthLocation geocentric ITRS coordinates from the object's geocentric ITRS coordinates,
+    put the resulting vector into a topocentric ITRS frame and then transform to
+    `~astropy.coordinates.AltAz` or `~astropy.coordinates.HADec`. The other way around is
+    to transform an observed `~astropy.coordinates.AltAz` or `~astropy.coordinates.HADec`
+    position to a topocentric ITRS frame and add the observing site's EarthLocation geocentric
+    ITRS coordinates to yield the object's geocentric ITRS coordinates.
+
+    On the other hand, using ``transform_to`` to transform geocentric ITRS coordinates to
+    topocentric ITRS, observed `~astropy.coordinates.AltAz`, or observed
+    `~astropy.coordinates.HADec` coordinates includes the difference between stellar aberration
+    from the point of view of an observer at the geocenter and stellar aberration from the
+    point of view of an observer on the surface of the Earth. If the geocentric ITRS
+    coordinates of the object include stellar aberration at the geocenter (e.g. certain ILRS
+    ephemerides), then this is the way to go.
+
+    Note to ILRS ephemeris users: Astropy does not currently consider relativistic
+    effects of the Earth's gravatational field. Nor do the `~astropy.coordinates.AltAz`
+    or `~astropy.coordinates.HADec` refraction corrections compute the change in the
+    range due to the curved path of light through the atmosphere, so Astropy is no
+    substitute for the ILRS software in these respects.
     """
 
     default_representation = CartesianRepresentation
     default_differential = CartesianDifferential
 
     obstime = TimeAttribute(default=DEFAULT_OBSTIME)
+    location = EarthLocationAttribute(default=EARTH_CENTER)
 
     @property
     def earth_location(self):
diff --git a/astropy/coordinates/builtin_frames/itrs_observed_transforms.py b/astropy/coordinates/builtin_frames/itrs_observed_transforms.py
new file mode 100644
index 0000000000..30f40fc2d7
--- /dev/null
+++ b/astropy/coordinates/builtin_frames/itrs_observed_transforms.py
@@ -0,0 +1,131 @@
+# Licensed under a 3-clause BSD style license - see LICENSE.rst
+"""
+Contains direct transformations between ITRS and observed coordinate systems.
+"""
+
+import numpy as np
+import erfa
+
+from astropy import units as u
+from astropy.coordinates.baseframe import frame_transform_graph
+from astropy.coordinates.matrix_utilities import matrix_transpose, rotation_matrix
+from astropy.coordinates.representation import CartesianRepresentation
+from astropy.coordinates.transformations import FunctionTransformWithFiniteDifference
+
+from .altaz import AltAz
+from .hadec import HADec
+from .itrs import ITRS
+
+# Minimum cos(alt) and sin(alt) for refraction purposes.
+CELMIN = 1e-6
+SELMIN = 0.05
+NORTH_POLE = 90.0 * u.deg
+
+
+def itrs_to_altaz_mat(lon, lat):
+    """Form the rotation matrix from ITRS to AltAz."""
+    minus_x = np.eye(3)
+    minus_x[0][0] = -1.0
+    return (minus_x
+            @ rotation_matrix(NORTH_POLE - lat, 'y')
+            @ rotation_matrix(lon, 'z'))
+
+
+def itrs_to_hadec_mat(lon):
+    """Form the rotation matrix from ITRS to HADec."""
+    minus_y = np.eye(3)
+    minus_y[1][1] = -1.0
+    return minus_y @ rotation_matrix(lon, 'z')
+
+
+def altaz_to_hadec_mat(lat):
+    """Form the rotation matrix from AltAz to HADec."""
+    z180 = np.eye(3)
+    z180[0][0] = -1.0
+    z180[1][1] = -1.0
+    return z180 @ rotation_matrix(NORTH_POLE - lat, 'y')
+
+
+def add_refraction(aa_crepr, observed_frame):
+    """Add atmospheric refraction to an AltAz Cartesian representation."""
+    refa, refb = erfa.refco(
+        observed_frame.pressure.to_value(u.hPa),
+        observed_frame.temperature.to_value(u.deg_C),
+        observed_frame.relative_humidity.value,
+        observed_frame.obswl.to_value(u.micron)
+    )
+    norm, uv = erfa.pn(aa_crepr.get_xyz(xyz_axis=-1).to_value())
+    sel = np.maximum(uv[..., 2], SELMIN)
+    cel = np.maximum(np.sqrt(uv[..., 0] ** 2 + uv[..., 1] ** 2), CELMIN)
+    tan_z = cel / sel
+    w = refb * tan_z ** 2
+    delta_el = (refa + w) * tan_z / (1.0 + (refa + 3.0 * w) / (sel ** 2))
+    cosdel = 1.0 - 0.5 * delta_el ** 2
+    f = cosdel - delta_el * sel / cel
+    uv[..., 0] *= f
+    uv[..., 1] *= f
+    uv[..., 2] = cosdel * uv[..., 2] + delta_el * cel
+    norm2, uv = erfa.pn(uv)
+    uv = erfa.sxp(norm, uv)
+    return CartesianRepresentation(uv, xyz_axis=-1, unit=aa_crepr.x.unit, copy=False)
+
+
+def remove_refraction(aa_crepr, observed_frame):
+    """Remove atmospheric refraction from an AltAz Cartesian representation."""
+    refa, refb = erfa.refco(
+        observed_frame.pressure.to_value(u.hPa),
+        observed_frame.temperature.to_value(u.deg_C),
+        observed_frame.relative_humidity.value,
+        observed_frame.obswl.to_value(u.micron)
+    )
+    norm, uv = erfa.pn(aa_crepr.get_xyz(xyz_axis=-1).to_value())
+    sel = np.maximum(uv[..., 2], SELMIN)
+    cel = np.sqrt(uv[..., 0] ** 2 + uv[..., 1] ** 2)
+    tan_z = cel / sel
+    delta_el = (refa + refb * tan_z ** 2) * tan_z
+    az, el = erfa.c2s(uv)
+    el -= delta_el
+    uv = erfa.s2c(az, el)
+    uv = erfa.sxp(norm, uv)
+    return CartesianRepresentation(uv, xyz_axis=-1, unit=aa_crepr.x.unit, copy=False)
+
+
+@frame_transform_graph.transform(FunctionTransformWithFiniteDifference, ITRS, AltAz)
+@frame_transform_graph.transform(FunctionTransformWithFiniteDifference, ITRS, HADec)
+def itrs_to_observed(itrs_coo, observed_frame):
+    if (np.any(itrs_coo.location != observed_frame.location) or
+            np.any(itrs_coo.obstime != observed_frame.obstime)):
+        itrs_coo = itrs_coo.transform_to(ITRS(obstime=observed_frame.obstime,
+                                              location=observed_frame.location))
+
+    lon, lat, height = observed_frame.location.to_geodetic('WGS84')
+
+    if isinstance(observed_frame, AltAz) or (observed_frame.pressure > 0.0):
+        crepr = itrs_coo.cartesian.transform(itrs_to_altaz_mat(lon, lat))
+        if observed_frame.pressure > 0.0:
+            crepr = add_refraction(crepr, observed_frame)
+            if isinstance(observed_frame, HADec):
+                crepr = crepr.transform(altaz_to_hadec_mat(lat))
+    else:
+        crepr = itrs_coo.cartesian.transform(itrs_to_hadec_mat(lon))
+    return observed_frame.realize_frame(crepr)
+
+
+@frame_transform_graph.transform(FunctionTransformWithFiniteDifference, AltAz, ITRS)
+@frame_transform_graph.transform(FunctionTransformWithFiniteDifference, HADec, ITRS)
+def observed_to_itrs(observed_coo, itrs_frame):
+    lon, lat, height = observed_coo.location.to_geodetic('WGS84')
+
+    if isinstance(observed_coo, AltAz) or (observed_coo.pressure > 0.0):
+        crepr = observed_coo.cartesian
+        if observed_coo.pressure > 0.0:
+            if isinstance(observed_coo, HADec):
+                crepr = crepr.transform(matrix_transpose(altaz_to_hadec_mat(lat)))
+            crepr = remove_refraction(crepr, observed_coo)
+        crepr = crepr.transform(matrix_transpose(itrs_to_altaz_mat(lon, lat)))
+    else:
+        crepr = observed_coo.cartesian.transform(matrix_transpose(itrs_to_hadec_mat(lon)))
+
+    itrs_at_obs_time = ITRS(crepr, obstime=observed_coo.obstime,
+                            location=observed_coo.location)
+    return itrs_at_obs_time.transform_to(itrs_frame)
diff --git a/docs/changes/coordinates/13398.feature.rst b/docs/changes/coordinates/13398.feature.rst
new file mode 100644
index 0000000000..f238e7544a
--- /dev/null
+++ b/docs/changes/coordinates/13398.feature.rst
@@ -0,0 +1,6 @@
+Adds new topocentric ITRS frame and direct transforms to and from the observed
+frames ``AltAz`` and ``HADec`` with the ability to add or remove refraction
+corrections as required. Since these frames are all within the ITRS, there are
+no corrections applied other than refraction in the transforms. This makes the
+topocentric ITRS frame and these transforms convenient for observers of near
+Earth objects where stellar aberration should be omitted.
diff --git a/docs/coordinates/spectralcoord.rst b/docs/coordinates/spectralcoord.rst
index 4115a6a93e..c831c4996c 100644
--- a/docs/coordinates/spectralcoord.rst
+++ b/docs/coordinates/spectralcoord.rst
@@ -237,7 +237,7 @@ velocity frame transformation)::
     >>> from astropy.time import Time
     >>> alma = location.get_itrs(obstime=Time('2019-04-24T02:32:10'))
     >>> alma  # doctest: +FLOAT_CMP
-    <ITRS Coordinate (obstime=2019-04-24T02:32:10.000): (x, y, z) in m
+    <ITRS Coordinate (obstime=2019-04-24T02:32:10.000, location=(0., 0., 0.) km): (x, y, z) in m
         (2225015.30883296, -5440016.41799762, -2481631.27428014)>
 
 ITRS here stands for International Terrestrial Reference System which is a 3D
@@ -269,7 +269,7 @@ have been measured (for the purposes of the example here we will assume we have
     ...                         observer=alma, target=ttau)  # doctest: +IGNORE_WARNINGS
     >>> sc_ttau  # doctest: +FLOAT_CMP +REMOTE_DATA
     <SpectralCoord
-       (observer: <ITRS Coordinate (obstime=2019-04-24T02:32:10.000): (x, y, z) in m
+       (observer:  <ITRS Coordinate (obstime=2019-04-24T02:32:10.000, location=(0., 0., 0.) km): (x, y, z) in m
                       (2225015.30883296, -5440016.41799762, -2481631.27428014)
                    (v_x, v_y, v_z) in km / s
                       (0., 0., 0.)>

diff --git a/astropy/io/fits/card.py b/astropy/io/fits/card.py
index 118bfced89..1b3285ddce 100644
--- a/astropy/io/fits/card.py
+++ b/astropy/io/fits/card.py
@@ -1298,31 +1298,17 @@ def _format_value(value):
 
 
 def _format_float(value):
-    """Format a floating number to make sure it gets the decimal point."""
-    value_str = f"{value:.16G}"
-    if "." not in value_str and "E" not in value_str:
-        value_str += ".0"
-    elif "E" in value_str:
-        # On some Windows builds of Python (and possibly other platforms?) the
-        # exponent is zero-padded out to, it seems, three digits.  Normalize
-        # the format to pad only to two digits.
-        significand, exponent = value_str.split("E")
-        if exponent[0] in ("+", "-"):
-            sign = exponent[0]
-            exponent = exponent[1:]
-        else:
-            sign = ""
-        value_str = f"{significand}E{sign}{int(exponent):02d}"
+    """Format a floating number to make sure it is at most 20 characters."""
+    value_str = str(value).replace("e", "E")
 
     # Limit the value string to at most 20 characters.
-    str_len = len(value_str)
-
-    if str_len > 20:
+    if (str_len := len(value_str)) > 20:
         idx = value_str.find("E")
-
         if idx < 0:
+            # No scientific notation, truncate decimal places
             value_str = value_str[:20]
         else:
+            # Scientific notation, truncate significand (mantissa)
             value_str = value_str[: 20 - (str_len - idx)] + value_str[idx:]
 
     return value_str

diff --git a/astropy/io/fits/diff.py b/astropy/io/fits/diff.py
index 100cdf1b8c..d3608ef01d 100644
--- a/astropy/io/fits/diff.py
+++ b/astropy/io/fits/diff.py
@@ -1449,7 +1449,7 @@ class TableDataDiff(_BaseDiff):
                 arrb.dtype, np.floating
             ):
                 diffs = where_not_allclose(arra, arrb, rtol=self.rtol, atol=self.atol)
-            elif "P" in col.format:
+            elif "P" in col.format or "Q" in col.format:
                 diffs = (
                     [
                         idx

diff --git a/astropy/nddata/mixins/ndarithmetic.py b/astropy/nddata/mixins/ndarithmetic.py
index 4153dfccb2..56a8678791 100644
--- a/astropy/nddata/mixins/ndarithmetic.py
+++ b/astropy/nddata/mixins/ndarithmetic.py
@@ -520,7 +520,7 @@ class NDArithmeticMixin:
         elif self.mask is None and operand is not None:
             # Make a copy so there is no reference in the result.
             return deepcopy(operand.mask)
-        elif operand is None:
+        elif operand is None or operand.mask is None:
             return deepcopy(self.mask)
         else:
             # Now lets calculate the resulting mask (operation enforces copy)

diff --git a/astropy/utils/misc.py b/astropy/utils/misc.py
index de3fb01d18..4f29128fc6 100644
--- a/astropy/utils/misc.py
+++ b/astropy/utils/misc.py
@@ -528,9 +528,9 @@ class InheritDocstrings(type):
                 not key.startswith('_'))
 
         for key, val in dct.items():
-            if (inspect.isfunction(val) and
-                is_public_member(key) and
-                val.__doc__ is None):
+            if ((inspect.isfunction(val) or inspect.isdatadescriptor(val)) and
+                    is_public_member(key) and
+                    val.__doc__ is None):
                 for base in cls.__mro__[1:]:
                     super_method = getattr(base, key, None)
                     if super_method is not None:

diff --git a/django/core/management/base.py b/django/core/management/base.py
index 0c3a981290..c725e5b75e 100644
--- a/django/core/management/base.py
+++ b/django/core/management/base.py
@@ -95,7 +95,7 @@ class DjangoHelpFormatter(HelpFormatter):
     """
     show_last = {
         '--version', '--verbosity', '--traceback', '--settings', '--pythonpath',
-        '--no-color', '--force-color',
+        '--no-color', '--force-color', '--skip-checks',
     }
 
     def _reordered_actions(self, actions):
@@ -223,7 +223,7 @@ class BaseCommand:
     requires_system_checks = True
     # Arguments, common to all commands, which aren't defined by the argument
     # parser.
-    base_stealth_options = ('skip_checks', 'stderr', 'stdout')
+    base_stealth_options = ('stderr', 'stdout')
     # Command-specific options not defined by the argument parser.
     stealth_options = ()
 
@@ -286,6 +286,11 @@ class BaseCommand:
             '--force-color', action='store_true',
             help='Force colorization of the command output.',
         )
+        if self.requires_system_checks:
+            parser.add_argument(
+                '--skip-checks', action='store_true',
+                help='Skip system checks.',
+            )
         self.add_arguments(parser)
         return parser
 
@@ -357,7 +362,7 @@ class BaseCommand:
         if options.get('stderr'):
             self.stderr = OutputWrapper(options['stderr'])
 
-        if self.requires_system_checks and not options.get('skip_checks'):
+        if self.requires_system_checks and not options['skip_checks']:
             self.check()
         if self.requires_migrations_checks:
             self.check_migrations()
diff --git a/docs/ref/django-admin.txt b/docs/ref/django-admin.txt
index b531978dd6..a269f6f8c6 100644
--- a/docs/ref/django-admin.txt
+++ b/docs/ref/django-admin.txt
@@ -1724,6 +1724,19 @@ Forces colorization of the command output if it would otherwise be disabled
 as discussed in :ref:`syntax-coloring`. For example, you may want to pipe
 colored output to another command.
 
+.. django-admin-option:: --skip-checks
+
+.. versionadded:: 3.0
+
+Skips running system checks prior to running the command. This option is only
+available if the
+:attr:`~django.core.management.BaseCommand.requires_system_checks` command
+attribute is set to ``True``.
+
+Example usage::
+
+    django-admin migrate --skip-checks
+
 Extra niceties
 ==============
 
diff --git a/docs/releases/3.0.txt b/docs/releases/3.0.txt
index e4a9789efb..66dfde0b5d 100644
--- a/docs/releases/3.0.txt
+++ b/docs/releases/3.0.txt
@@ -180,6 +180,9 @@ Management Commands
 * :djadmin:`inspectdb` now introspects :class:`~django.db.models.OneToOneField`
   when a foreign key has a unique or primary key constraint.
 
+* The new :option:`--skip-checks` option skips running system checks prior to
+  running the command.
+
 Migrations
 ~~~~~~~~~~
 

diff --git a/django/contrib/admin/filters.py b/django/contrib/admin/filters.py
index d65e01d5e2..a9e5563c6c 100644
--- a/django/contrib/admin/filters.py
+++ b/django/contrib/admin/filters.py
@@ -193,11 +193,17 @@ class RelatedFieldListFilter(FieldListFilter):
     def expected_parameters(self):
         return [self.lookup_kwarg, self.lookup_kwarg_isnull]
 
-    def field_choices(self, field, request, model_admin):
-        ordering = ()
+    def field_admin_ordering(self, field, request, model_admin):
+        """
+        Return the model admin's ordering for related field, if provided.
+        """
         related_admin = model_admin.admin_site._registry.get(field.remote_field.model)
         if related_admin is not None:
-            ordering = related_admin.get_ordering(request)
+            return related_admin.get_ordering(request)
+        return ()
+
+    def field_choices(self, field, request, model_admin):
+        ordering = self.field_admin_ordering(field, request, model_admin)
         return field.get_choices(include_blank=False, ordering=ordering)
 
     def choices(self, changelist):
@@ -419,4 +425,5 @@ FieldListFilter.register(lambda f: True, AllValuesFieldListFilter)
 class RelatedOnlyFieldListFilter(RelatedFieldListFilter):
     def field_choices(self, field, request, model_admin):
         pk_qs = model_admin.get_queryset(request).distinct().values_list('%s__pk' % self.field_path, flat=True)
-        return field.get_choices(include_blank=False, limit_choices_to={'pk__in': pk_qs})
+        ordering = self.field_admin_ordering(field, request, model_admin)
+        return field.get_choices(include_blank=False, limit_choices_to={'pk__in': pk_qs}, ordering=ordering)
diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index 194514c900..1aad845470 100644
--- a/django/db/models/fields/__init__.py
+++ b/django/db/models/fields/__init__.py
@@ -825,9 +825,11 @@ class Field(RegisterLookupMixin):
             if hasattr(self.remote_field, 'get_related_field')
             else 'pk'
         )
+        qs = rel_model._default_manager.complex_filter(limit_choices_to)
+        if ordering:
+            qs = qs.order_by(*ordering)
         return (blank_choice if include_blank else []) + [
-            (choice_func(x), str(x))
-            for x in rel_model._default_manager.complex_filter(limit_choices_to).order_by(*ordering)
+            (choice_func(x), str(x)) for x in qs
         ]
 
     def value_to_string(self, obj):
diff --git a/django/db/models/fields/reverse_related.py b/django/db/models/fields/reverse_related.py
index eb6b934259..700410a086 100644
--- a/django/db/models/fields/reverse_related.py
+++ b/django/db/models/fields/reverse_related.py
@@ -122,8 +122,11 @@ class ForeignObjectRel(FieldCacheMixin):
         Analog of django.db.models.fields.Field.get_choices(), provided
         initially for utilization by RelatedFieldListFilter.
         """
+        qs = self.related_model._default_manager.all()
+        if ordering:
+            qs = qs.order_by(*ordering)
         return (blank_choice if include_blank else []) + [
-            (x.pk, str(x)) for x in self.related_model._default_manager.order_by(*ordering)
+            (x.pk, str(x)) for x in qs
         ]
 
     def is_hidden(self):

diff --git a/django/contrib/auth/backends.py b/django/contrib/auth/backends.py
index f4b1722757..a3765ae0f1 100644
--- a/django/contrib/auth/backends.py
+++ b/django/contrib/auth/backends.py
@@ -39,6 +39,8 @@ class ModelBackend(BaseBackend):
     def authenticate(self, request, username=None, password=None, **kwargs):
         if username is None:
             username = kwargs.get(UserModel.USERNAME_FIELD)
+        if username is None or password is None:
+            return
         try:
             user = UserModel._default_manager.get_by_natural_key(username)
         except UserModel.DoesNotExist:

diff --git a/django/core/mail/utils.py b/django/core/mail/utils.py
index d18dfe4667..f2387c394a 100644
--- a/django/core/mail/utils.py
+++ b/django/core/mail/utils.py
@@ -13,7 +13,7 @@ class CachedDnsName:
 
     def get_fqdn(self):
         if not hasattr(self, '_fqdn'):
-            self._fqdn = socket.getfqdn()
+            self._fqdn = socket.getfqdn().encode('idna').decode('ascii')
         return self._fqdn
 
 

diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index 35f3c5e1ea..8e55bd092d 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -1702,7 +1702,9 @@ class Query(BaseExpression):
         handle.
         """
         filter_lhs, filter_rhs = filter_expr
-        if isinstance(filter_rhs, F):
+        if isinstance(filter_rhs, OuterRef):
+            filter_expr = (filter_lhs, OuterRef(filter_rhs))
+        elif isinstance(filter_rhs, F):
             filter_expr = (filter_lhs, OuterRef(filter_rhs.name))
         # Generate the inner query.
         query = Query(self.model)

diff --git a/django/db/migrations/serializer.py b/django/db/migrations/serializer.py
index 7d226955d5..ea3da33f77 100644
--- a/django/db/migrations/serializer.py
+++ b/django/db/migrations/serializer.py
@@ -1,3 +1,4 @@
+# Serializes values into migration-safe Python source code.
 import builtins
 import collections.abc
 import datetime
@@ -269,7 +270,7 @@ class TypeSerializer(BaseSerializer):
             if module == builtins.__name__:
                 return self.value.__name__, set()
             else:
-                return "%s.%s" % (module, self.value.__name__), {"import %s" % module}
+                return "%s.%s" % (module, self.value.__qualname__), {"import %s" % module}
 
 
 class UUIDSerializer(BaseSerializer):

diff --git a/django/db/models/enums.py b/django/db/models/enums.py
index f48143ddaf..51821a2b45 100644
--- a/django/db/models/enums.py
+++ b/django/db/models/enums.py
@@ -31,6 +31,7 @@ class ChoicesMeta(enum.EnumMeta):
         # that is passed in as "self" as the value to use when looking up the
         # label in the choices.
         cls.label = property(lambda self: cls._value2label_map_.get(self.value))
+        cls.do_not_call_in_templates = True
         return enum.unique(cls)
 
     def __contains__(cls, member):
diff --git a/docs/releases/3.0.3.txt b/docs/releases/3.0.3.txt
index 27ace475d1..ab5a2fd84b 100644
--- a/docs/releases/3.0.3.txt
+++ b/docs/releases/3.0.3.txt
@@ -20,3 +20,6 @@ Bugfixes
 * Relaxed the system check added in Django 3.0 to reallow use of a sublanguage
   in the :setting:`LANGUAGE_CODE` setting, when a base language is available in
   Django but the sublanguage is not (:ticket:`31141`).
+
+* Added support for using enumeration types ``TextChoices``,
+  ``IntegerChoices``, and ``Choices`` in templates (:ticket:`31154`).

diff --git a/django/db/models/base.py b/django/db/models/base.py
index 8ea6c05ef9..24453e218a 100644
--- a/django/db/models/base.py
+++ b/django/db/models/base.py
@@ -202,7 +202,7 @@ class ModelBase(type):
                 continue
             # Locate OneToOneField instances.
             for field in base._meta.local_fields:
-                if isinstance(field, OneToOneField):
+                if isinstance(field, OneToOneField) and field.remote_field.parent_link:
                     related = resolve_relation(new_class, field.remote_field.model)
                     parent_links[make_model_tuple(related)] = field
 
diff --git a/django/db/models/options.py b/django/db/models/options.py
index a375f6ba1d..08c80bb6c8 100644
--- a/django/db/models/options.py
+++ b/django/db/models/options.py
@@ -5,7 +5,7 @@ from collections import defaultdict
 
 from django.apps import apps
 from django.conf import settings
-from django.core.exceptions import FieldDoesNotExist, ImproperlyConfigured
+from django.core.exceptions import FieldDoesNotExist
 from django.db import connections
 from django.db.models import Manager
 from django.db.models.fields import AutoField
@@ -251,10 +251,6 @@ class Options:
                     field = already_created[0]
                 field.primary_key = True
                 self.setup_pk(field)
-                if not field.remote_field.parent_link:
-                    raise ImproperlyConfigured(
-                        'Add parent_link=True to %s.' % field,
-                    )
             else:
                 auto = AutoField(verbose_name='ID', primary_key=True, auto_created=True)
                 model.add_to_class('id', auto)

diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index c913267476..1623263964 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -305,6 +305,7 @@ class Query(BaseExpression):
             obj.annotation_select_mask = None
         else:
             obj.annotation_select_mask = self.annotation_select_mask.copy()
+        obj.combined_queries = tuple(query.clone() for query in self.combined_queries)
         # _annotation_select_cache cannot be copied, as doing so breaks the
         # (necessary) state in which both annotations and
         # _annotation_select_cache point to the same underlying objects.
@@ -1777,6 +1778,8 @@ class Query(BaseExpression):
 
     def set_empty(self):
         self.where.add(NothingNode(), AND)
+        for query in self.combined_queries:
+            query.set_empty()
 
     def is_empty(self):
         return any(isinstance(c, NothingNode) for c in self.where.children)

diff --git a/AUTHORS b/AUTHORS
index 16272bdf28..5c50598ddc 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -449,6 +449,7 @@ answer newbie questions, and generally made Django that much better:
     Joao Oliveira <[email protected]>
     Joao Pedro Silva <[email protected]>
     Joe Heck <http://www.rhonabwy.com/wp/>
+    Joe Jackson <[email protected]>
     Joel Bohman <[email protected]>
     Joel Heenan <[email protected]>
     Joel Watts <[email protected]>
diff --git a/django/db/models/functions/datetime.py b/django/db/models/functions/datetime.py
index b6594b043b..6828980733 100644
--- a/django/db/models/functions/datetime.py
+++ b/django/db/models/functions/datetime.py
@@ -292,7 +292,7 @@ class TruncDate(TruncBase):
     def as_sql(self, compiler, connection):
         # Cast to date rather than truncate to date.
         lhs, lhs_params = compiler.compile(self.lhs)
-        tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
+        tzname = self.get_tzname()
         sql = connection.ops.datetime_cast_date_sql(lhs, tzname)
         return sql, lhs_params
 
@@ -305,7 +305,7 @@ class TruncTime(TruncBase):
     def as_sql(self, compiler, connection):
         # Cast to time rather than truncate to time.
         lhs, lhs_params = compiler.compile(self.lhs)
-        tzname = timezone.get_current_timezone_name() if settings.USE_TZ else None
+        tzname = self.get_tzname()
         sql = connection.ops.datetime_cast_time_sql(lhs, tzname)
         return sql, lhs_params
 
diff --git a/docs/ref/models/database-functions.txt b/docs/ref/models/database-functions.txt
index f5efdb7e87..3121a36fa9 100644
--- a/docs/ref/models/database-functions.txt
+++ b/docs/ref/models/database-functions.txt
@@ -623,20 +623,28 @@ that deal with date-parts can be used with ``DateField``::
 ``DateTimeField`` truncation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. class:: TruncDate(expression, **extra)
+.. class:: TruncDate(expression, tzinfo=None, **extra)
 
     .. attribute:: lookup_name = 'date'
     .. attribute:: output_field = DateField()
 
+    .. versionchanged:: 3.2
+
+        The ``tzinfo`` parameter was added.
+
 ``TruncDate`` casts ``expression`` to a date rather than using the built-in SQL
 truncate function. It's also registered as a transform on  ``DateTimeField`` as
 ``__date``.
 
-.. class:: TruncTime(expression, **extra)
+.. class:: TruncTime(expression, tzinfo=None, **extra)
 
     .. attribute:: lookup_name = 'time'
     .. attribute:: output_field = TimeField()
 
+    .. versionchanged:: 3.2
+
+        The ``tzinfo`` parameter was added.
+
 ``TruncTime`` casts ``expression`` to a time rather than using the built-in SQL
 truncate function. It's also registered as a transform on ``DateTimeField`` as
 ``__time``.
diff --git a/docs/releases/3.2.txt b/docs/releases/3.2.txt
index d29a582d74..9017c33138 100644
--- a/docs/releases/3.2.txt
+++ b/docs/releases/3.2.txt
@@ -290,6 +290,11 @@ Models
   distinct fields if there's only one field specified in
   :meth:`.QuerySet.distinct`.
 
+* The new ``tzinfo`` parameter of the
+  :class:`~django.db.models.functions.TruncDate` and
+  :class:`~django.db.models.functions.TruncTime` database functions allows
+  truncating datetimes in a specific timezone.
+
 Pagination
 ~~~~~~~~~~
 

diff --git a/django/db/models/fields/__init__.py b/django/db/models/fields/__init__.py
index 28374272f4..15e69d3704 100644
--- a/django/db/models/fields/__init__.py
+++ b/django/db/models/fields/__init__.py
@@ -516,17 +516,37 @@ class Field(RegisterLookupMixin):
     def __eq__(self, other):
         # Needed for @total_ordering
         if isinstance(other, Field):
-            return self.creation_counter == other.creation_counter
+            return (
+                self.creation_counter == other.creation_counter and
+                getattr(self, 'model', None) == getattr(other, 'model', None)
+            )
         return NotImplemented
 
     def __lt__(self, other):
         # This is needed because bisect does not take a comparison function.
+        # Order by creation_counter first for backward compatibility.
         if isinstance(other, Field):
-            return self.creation_counter < other.creation_counter
+            if (
+                self.creation_counter != other.creation_counter or
+                not hasattr(self, 'model') and not hasattr(other, 'model')
+            ):
+                return self.creation_counter < other.creation_counter
+            elif hasattr(self, 'model') != hasattr(other, 'model'):
+                return not hasattr(self, 'model')  # Order no-model fields first
+            else:
+                # creation_counter's are equal, compare only models.
+                return (
+                    (self.model._meta.app_label, self.model._meta.model_name) <
+                    (other.model._meta.app_label, other.model._meta.model_name)
+                )
         return NotImplemented
 
     def __hash__(self):
-        return hash(self.creation_counter)
+        return hash((
+            self.creation_counter,
+            self.model._meta.app_label if hasattr(self, 'model') else None,
+            self.model._meta.model_name if hasattr(self, 'model') else None,
+        ))
 
     def __deepcopy__(self, memodict):
         # We don't have to deepcopy very much here, since most things are not

diff --git a/django/db/models/query.py b/django/db/models/query.py
index b48d0df9c0..85cd8311a7 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -210,6 +210,8 @@ class QuerySet:
 
     @query.setter
     def query(self, value):
+        if value.values_select:
+            self._iterable_class = ValuesIterable
         self._query = value
 
     def as_manager(cls):
diff --git a/docs/ref/models/querysets.txt b/docs/ref/models/querysets.txt
index 228e2cf736..7f55684e08 100644
--- a/docs/ref/models/querysets.txt
+++ b/docs/ref/models/querysets.txt
@@ -106,6 +106,20 @@ the query construction and is not part of the public API. However, it is safe
 (and fully supported) to pickle and unpickle the attribute's contents as
 described here.
 
+.. admonition:: Restrictions on ``QuerySet.values_list()``
+
+    If you recreate :meth:`QuerySet.values_list` using the pickled ``query``
+    attribute, it will be converted to :meth:`QuerySet.values`::
+
+        >>> import pickle
+        >>> qs = Blog.objects.values_list('id', 'name')
+        >>> qs
+        <QuerySet [(1, 'Beatles Blog')]>
+        >>> reloaded_qs = Blog.objects.all()
+        >>> reloaded_qs.query = pickle.loads(pickle.dumps(qs.query))
+        >>> reloaded_qs
+        <QuerySet [{'id': 1, 'name': 'Beatles Blog'}]>
+
 .. admonition:: You can't share pickles between versions
 
     Pickles of ``QuerySets`` are only valid for the version of Django that

diff --git a/django/db/models/query.py b/django/db/models/query.py
index 85cd8311a7..67ffe7f000 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -1224,7 +1224,12 @@ class QuerySet:
             return True
         if self.query.extra_order_by or self.query.order_by:
             return True
-        elif self.query.default_ordering and self.query.get_meta().ordering:
+        elif (
+            self.query.default_ordering and
+            self.query.get_meta().ordering and
+            # A default ordering doesn't affect GROUP BY queries.
+            not self.query.group_by
+        ):
             return True
         else:
             return False
diff --git a/docs/releases/3.1.2.txt b/docs/releases/3.1.2.txt
index 1243654bfb..f9e45370ab 100644
--- a/docs/releases/3.1.2.txt
+++ b/docs/releases/3.1.2.txt
@@ -11,3 +11,8 @@ Bugfixes
 
 * Fixed a bug in Django 3.1 where ``FileField`` instances with a callable
   storage were not correctly deconstructed (:ticket:`31941`).
+
+* Fixed a regression in Django 3.1 where the :attr:`.QuerySet.ordered`
+  attribute returned incorrectly ``True`` for ``GROUP BY`` queries (e.g.
+  ``.annotate().values()``) on models with ``Meta.ordering``. A model's
+  ``Meta.ordering`` doesn't affect such queries (:ticket:`31990`).

diff --git a/django/contrib/auth/tokens.py b/django/contrib/auth/tokens.py
index 93e2d71af2..a022ce3f91 100644
--- a/django/contrib/auth/tokens.py
+++ b/django/contrib/auth/tokens.py
@@ -1,3 +1,4 @@
+# Password reset token generation.
 from datetime import datetime
 
 from django.conf import settings
@@ -78,9 +79,9 @@ class PasswordResetTokenGenerator:
 
     def _make_hash_value(self, user, timestamp):
         """
-        Hash the user's primary key and some user state that's sure to change
-        after a password reset to produce a token that invalidated when it's
-        used:
+        Hash the user's primary key, email (if available), and some user state
+        that's sure to change after a password reset to produce a token that is
+        invalidated when it's used:
         1. The password field will change upon a password reset (even if the
            same password is chosen, due to password salting).
         2. The last_login field will usually be updated very shortly after
@@ -94,7 +95,9 @@ class PasswordResetTokenGenerator:
         # Truncate microseconds so that tokens are consistent even if the
         # database doesn't support microseconds.
         login_timestamp = '' if user.last_login is None else user.last_login.replace(microsecond=0, tzinfo=None)
-        return str(user.pk) + user.password + str(login_timestamp) + str(timestamp)
+        email_field = user.get_email_field_name()
+        email = getattr(user, email_field, '') or ''
+        return f'{user.pk}{user.password}{login_timestamp}{timestamp}{email}'
 
     def _num_seconds(self, dt):
         return int((dt - datetime(2001, 1, 1)).total_seconds())
diff --git a/docs/releases/3.2.txt b/docs/releases/3.2.txt
index 10842af4fc..232b20cb23 100644
--- a/docs/releases/3.2.txt
+++ b/docs/releases/3.2.txt
@@ -552,6 +552,9 @@ Miscellaneous
   ``False`` if the file cannot be locked, instead of raising
   :exc:`BlockingIOError`.
 
+* The password reset mechanism now invalidates tokens when the user email is
+  changed.
+
 .. _deprecated-features-3.2:
 
 Features deprecated in 3.2

diff --git a/django/contrib/auth/forms.py b/django/contrib/auth/forms.py
index b9eb33329f..20d8922799 100644
--- a/django/contrib/auth/forms.py
+++ b/django/contrib/auth/forms.py
@@ -56,16 +56,9 @@ class ReadOnlyPasswordHashField(forms.Field):
 
     def __init__(self, *args, **kwargs):
         kwargs.setdefault("required", False)
+        kwargs.setdefault('disabled', True)
         super().__init__(*args, **kwargs)
 
-    def bound_data(self, data, initial):
-        # Always return initial because the widget doesn't
-        # render an input field.
-        return initial
-
-    def has_changed(self, initial, data):
-        return False
-
 
 class UsernameField(forms.CharField):
     def to_python(self, value):
@@ -163,12 +156,6 @@ class UserChangeForm(forms.ModelForm):
         if user_permissions:
             user_permissions.queryset = user_permissions.queryset.select_related('content_type')
 
-    def clean_password(self):
-        # Regardless of what the user provides, return the initial value.
-        # This is done here, rather than on the field, because the
-        # field does not have access to the initial value
-        return self.initial.get('password')
-
 
 class AuthenticationForm(forms.Form):
     """
diff --git a/docs/releases/3.2.txt b/docs/releases/3.2.txt
index 7d374da0a7..2ab8546026 100644
--- a/docs/releases/3.2.txt
+++ b/docs/releases/3.2.txt
@@ -625,6 +625,11 @@ Miscellaneous
   using :option:`makemessages --locale` option, when they contain hyphens
   (``'-'``).
 
+* The ``django.contrib.auth.forms.ReadOnlyPasswordHashField`` form field is now
+  :attr:`~django.forms.Field.disabled` by default. Therefore
+  ``UserChangeForm.clean_password()`` is no longer required to return the
+  initial value.
+
 .. _deprecated-features-3.2:
 
 Features deprecated in 3.2
diff --git a/docs/topics/auth/customizing.txt b/docs/topics/auth/customizing.txt
index 6ab8305468..8314d9f171 100644
--- a/docs/topics/auth/customizing.txt
+++ b/docs/topics/auth/customizing.txt
@@ -1129,7 +1129,7 @@ code would be required in the app's ``admin.py`` file::
     class UserChangeForm(forms.ModelForm):
         """A form for updating users. Includes all the fields on
         the user, but replaces the password field with admin's
-        password hash display field.
+        disabled password hash display field.
         """
         password = ReadOnlyPasswordHashField()
 
@@ -1137,12 +1137,6 @@ code would be required in the app's ``admin.py`` file::
             model = MyUser
             fields = ('email', 'password', 'date_of_birth', 'is_active', 'is_admin')
 
-        def clean_password(self):
-            # Regardless of what the user provides, return the initial value.
-            # This is done here, rather than on the field, because the
-            # field does not have access to the initial value
-            return self.initial["password"]
-
 
     class UserAdmin(BaseUserAdmin):
         # The forms to add and change user instances
@@ -1182,3 +1176,10 @@ Finally, specify the custom model as the default user model for your project
 using the :setting:`AUTH_USER_MODEL` setting in your ``settings.py``::
 
     AUTH_USER_MODEL = 'customauth.MyUser'
+
+.. versionchanged:: 3.2
+
+    In older versions, ``ReadOnlyPasswordHashField`` is not
+    :attr:`~django.forms.Field.disabled` by default and
+    ``UserChangeForm.clean_password()`` is required to return the initial
+    value, whatever the user provides.

diff --git a/django/forms/boundfield.py b/django/forms/boundfield.py
index a061f15f87..3e92cba549 100644
--- a/django/forms/boundfield.py
+++ b/django/forms/boundfield.py
@@ -2,7 +2,7 @@ import re
 
 from django.core.exceptions import ValidationError
 from django.forms.utils import flatatt, pretty_name
-from django.forms.widgets import Textarea, TextInput
+from django.forms.widgets import MultiWidget, Textarea, TextInput
 from django.utils.functional import cached_property
 from django.utils.html import conditional_escape, format_html, html_safe
 from django.utils.safestring import mark_safe
@@ -233,7 +233,17 @@ class BoundField:
         widget = widget or self.field.widget
         attrs = dict(attrs)  # Copy attrs to avoid modifying the argument.
         if widget.use_required_attribute(self.initial) and self.field.required and self.form.use_required_attribute:
-            attrs['required'] = True
+            # MultiValueField has require_all_fields: if False, fall back
+            # on subfields.
+            if (
+                hasattr(self.field, 'require_all_fields') and
+                not self.field.require_all_fields and
+                isinstance(self.field.widget, MultiWidget)
+            ):
+                for subfield, subwidget in zip(self.field.fields, widget.widgets):
+                    subwidget.attrs['required'] = subwidget.use_required_attribute(self.initial) and subfield.required
+            else:
+                attrs['required'] = True
         if self.field.disabled:
             attrs['disabled'] = True
         return attrs

diff --git a/django/utils/datastructures.py b/django/utils/datastructures.py
index 871b016715..99f9ff2a72 100644
--- a/django/utils/datastructures.py
+++ b/django/utils/datastructures.py
@@ -25,6 +25,9 @@ class OrderedSet:
     def __iter__(self):
         return iter(self.dict)
 
+    def __reversed__(self):
+        return reversed(self.dict)
+
     def __contains__(self, item):
         return item in self.dict
 

diff --git a/django/forms/models.py b/django/forms/models.py
index 5dcf923c12..7effb202e3 100644
--- a/django/forms/models.py
+++ b/django/forms/models.py
@@ -1166,6 +1166,9 @@ class ModelChoiceIteratorValue:
     def __str__(self):
         return str(self.value)
 
+    def __hash__(self):
+        return hash(self.value)
+
     def __eq__(self, other):
         if isinstance(other, ModelChoiceIteratorValue):
             other = other.value

diff --git a/django/contrib/admin/options.py b/django/contrib/admin/options.py
index 66f3396a6b..c5968a79ed 100644
--- a/django/contrib/admin/options.py
+++ b/django/contrib/admin/options.py
@@ -1031,6 +1031,7 @@ class ModelAdmin(BaseModelAdmin):
         if search_fields and search_term:
             orm_lookups = [construct_search(str(search_field))
                            for search_field in search_fields]
+            term_queries = []
             for bit in smart_split(search_term):
                 if bit.startswith(('"', "'")) and bit[0] == bit[-1]:
                     bit = unescape_string_literal(bit)
@@ -1038,7 +1039,8 @@ class ModelAdmin(BaseModelAdmin):
                     *((orm_lookup, bit) for orm_lookup in orm_lookups),
                     _connector=models.Q.OR,
                 )
-                queryset = queryset.filter(or_queries)
+                term_queries.append(or_queries)
+            queryset = queryset.filter(models.Q(*term_queries))
             may_have_duplicates |= any(
                 lookup_spawns_duplicates(self.opts, search_spec)
                 for search_spec in orm_lookups

diff --git a/django/db/migrations/operations/models.py b/django/db/migrations/operations/models.py
index c120f5d32d..01c44a9a26 100644
--- a/django/db/migrations/operations/models.py
+++ b/django/db/migrations/operations/models.py
@@ -34,9 +34,12 @@ class ModelOperation(Operation):
     def reduce(self, operation, app_label):
         return (
             super().reduce(operation, app_label) or
-            not operation.references_model(self.name, app_label)
+            self.can_reduce_through(operation, app_label)
         )
 
+    def can_reduce_through(self, operation, app_label):
+        return not operation.references_model(self.name, app_label)
+
 
 class CreateModel(ModelOperation):
     """Create a model's table."""
@@ -528,6 +531,14 @@ class AlterTogetherOptionOperation(ModelOptionOperation):
     def migration_name_fragment(self):
         return 'alter_%s_%s' % (self.name_lower, self.option_name)
 
+    def can_reduce_through(self, operation, app_label):
+        return (
+            super().can_reduce_through(operation, app_label) or (
+                isinstance(operation, AlterTogetherOptionOperation) and
+                type(operation) is not type(self)
+            )
+        )
+
 
 class AlterUniqueTogether(AlterTogetherOptionOperation):
     """

diff --git a/django/db/models/fields/json.py b/django/db/models/fields/json.py
index fdca700c9d..7424f46e66 100644
--- a/django/db/models/fields/json.py
+++ b/django/db/models/fields/json.py
@@ -172,6 +172,10 @@ class ContainedBy(PostgresOperatorLookup):
 class HasKeyLookup(PostgresOperatorLookup):
     logical_operator = None
 
+    def compile_json_path_final_key(self, key_transform):
+        # Compile the final key without interpreting ints as array elements.
+        return ".%s" % json.dumps(key_transform)
+
     def as_sql(self, compiler, connection, template=None):
         # Process JSON path from the left-hand side.
         if isinstance(self.lhs, KeyTransform):
@@ -193,13 +197,10 @@ class HasKeyLookup(PostgresOperatorLookup):
                 *_, rhs_key_transforms = key.preprocess_lhs(compiler, connection)
             else:
                 rhs_key_transforms = [key]
-            rhs_params.append(
-                "%s%s"
-                % (
-                    lhs_json_path,
-                    compile_json_path(rhs_key_transforms, include_root=False),
-                )
-            )
+            *rhs_key_transforms, final_key = rhs_key_transforms
+            rhs_json_path = compile_json_path(rhs_key_transforms, include_root=False)
+            rhs_json_path += self.compile_json_path_final_key(final_key)
+            rhs_params.append(lhs_json_path + rhs_json_path)
         # Add condition for each key.
         if self.logical_operator:
             sql = "(%s)" % self.logical_operator.join([sql] * len(rhs_params))
@@ -253,6 +254,11 @@ class HasAnyKeys(HasKeys):
     logical_operator = " OR "
 
 
+class HasKeyOrArrayIndex(HasKey):
+    def compile_json_path_final_key(self, key_transform):
+        return compile_json_path([key_transform], include_root=False)
+
+
 class CaseInsensitiveMixin:
     """
     Mixin to allow case-insensitive comparison of JSON values on MySQL.
@@ -387,7 +393,7 @@ class KeyTransformTextLookupMixin:
 class KeyTransformIsNull(lookups.IsNull):
     # key__isnull=False is the same as has_key='key'
     def as_oracle(self, compiler, connection):
-        sql, params = HasKey(
+        sql, params = HasKeyOrArrayIndex(
             self.lhs.lhs,
             self.lhs.key_name,
         ).as_oracle(compiler, connection)
@@ -401,7 +407,7 @@ class KeyTransformIsNull(lookups.IsNull):
         template = "JSON_TYPE(%s, %%s) IS NULL"
         if not self.rhs:
             template = "JSON_TYPE(%s, %%s) IS NOT NULL"
-        return HasKey(self.lhs.lhs, self.lhs.key_name).as_sql(
+        return HasKeyOrArrayIndex(self.lhs.lhs, self.lhs.key_name).as_sql(
             compiler,
             connection,
             template=template,
@@ -466,7 +472,7 @@ class KeyTransformExact(JSONExact):
         rhs, rhs_params = super().process_rhs(compiler, connection)
         if rhs_params == ["null"]:
             # Field has key and it's NULL.
-            has_key_expr = HasKey(self.lhs.lhs, self.lhs.key_name)
+            has_key_expr = HasKeyOrArrayIndex(self.lhs.lhs, self.lhs.key_name)
             has_key_sql, has_key_params = has_key_expr.as_oracle(compiler, connection)
             is_null_expr = self.lhs.get_lookup("isnull")(self.lhs, True)
             is_null_sql, is_null_params = is_null_expr.as_sql(compiler, connection)

diff --git a/django/db/models/fields/related_lookups.py b/django/db/models/fields/related_lookups.py
index 1a845a1f7f..afea09b5a9 100644
--- a/django/db/models/fields/related_lookups.py
+++ b/django/db/models/fields/related_lookups.py
@@ -93,7 +93,6 @@ class RelatedIn(In):
             elif not getattr(self.rhs, "has_select_fields", True) and not getattr(
                 self.lhs.field.target_field, "primary_key", False
             ):
-                self.rhs.clear_select_clause()
                 if (
                     getattr(self.lhs.output_field, "primary_key", False)
                     and self.lhs.output_field.model == self.rhs.model
@@ -105,7 +104,7 @@ class RelatedIn(In):
                     target_field = self.lhs.field.name
                 else:
                     target_field = self.lhs.field.target_field.name
-                self.rhs.add_fields([target_field], True)
+                self.rhs.set_values([target_field])
         return super().get_prep_lookup()
 
     def as_sql(self, compiler, connection):
diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index 8419dc0d54..5dca423de4 100644
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -198,6 +198,7 @@ class Query(BaseExpression):
     select_for_update_of = ()
     select_for_no_key_update = False
     select_related = False
+    has_select_fields = False
     # Arbitrary limit for select_related to prevents infinite recursion.
     max_depth = 5
     # Holds the selects defined by a call to values() or values_list()
@@ -263,12 +264,6 @@ class Query(BaseExpression):
         elif len(self.annotation_select) == 1:
             return next(iter(self.annotation_select.values())).output_field
 
-    @property
-    def has_select_fields(self):
-        return bool(
-            self.select or self.annotation_select_mask or self.extra_select_mask
-        )
-
     @cached_property
     def base_table(self):
         for alias in self.alias_map:
@@ -2384,6 +2379,7 @@ class Query(BaseExpression):
         self.select_related = False
         self.clear_deferred_loading()
         self.clear_select_fields()
+        self.has_select_fields = True
 
         if fields:
             field_names = []

diff --git a/django/contrib/admin/options.py b/django/contrib/admin/options.py
index 5f07a4208a..7ba3c43cc6 100644
--- a/django/contrib/admin/options.py
+++ b/django/contrib/admin/options.py
@@ -1,3 +1,4 @@
+# Admin model configuration and request handling.
 import copy
 import json
 import re
@@ -2011,15 +2012,17 @@ class ModelAdmin(BaseModelAdmin):
             )
             if formset.is_valid():
                 changecount = 0
-                for form in formset.forms:
-                    if form.has_changed():
-                        obj = self.save_form(request, form, change=True)
-                        self.save_model(request, obj, form, change=True)
-                        self.save_related(request, form, formsets=[], change=True)
-                        change_msg = self.construct_change_message(request, form, None)
-                        self.log_change(request, obj, change_msg)
-                        changecount += 1
-
+                with transaction.atomic(using=router.db_for_write(self.model)):
+                    for form in formset.forms:
+                        if form.has_changed():
+                            obj = self.save_form(request, form, change=True)
+                            self.save_model(request, obj, form, change=True)
+                            self.save_related(request, form, formsets=[], change=True)
+                            change_msg = self.construct_change_message(
+                                request, form, None
+                            )
+                            self.log_change(request, obj, change_msg)
+                            changecount += 1
                 if changecount:
                     msg = ngettext(
                         "%(count)s %(name)s was changed successfully.",

diff --git a/django/db/models/fields/files.py b/django/db/models/fields/files.py
index 7a99b12691..04b3eb3473 100644
--- a/django/db/models/fields/files.py
+++ b/django/db/models/fields/files.py
@@ -295,8 +295,9 @@ class FileField(Field):
         if kwargs.get("max_length") == 100:
             del kwargs["max_length"]
         kwargs["upload_to"] = self.upload_to
-        if self.storage is not default_storage:
-            kwargs["storage"] = getattr(self, "_storage_callable", self.storage)
+        storage = getattr(self, "_storage_callable", self.storage)
+        if storage is not default_storage:
+            kwargs["storage"] = storage
         return name, path, args, kwargs
 
     def get_internal_type(self):

diff --git a/lib/matplotlib/legend.py b/lib/matplotlib/legend.py
index 44ab024698..1d85ba1a3f 100644
--- a/lib/matplotlib/legend.py
+++ b/lib/matplotlib/legend.py
@@ -360,7 +360,7 @@ class Legend(Artist):
         """
         # local import only to avoid circularity
         from matplotlib.axes import Axes
-        from matplotlib.figure import Figure
+        from matplotlib.figure import FigureBase
 
         super().__init__()
 
@@ -434,11 +434,13 @@ class Legend(Artist):
             self.isaxes = True
             self.axes = parent
             self.set_figure(parent.figure)
-        elif isinstance(parent, Figure):
+        elif isinstance(parent, FigureBase):
             self.isaxes = False
             self.set_figure(parent)
         else:
-            raise TypeError("Legend needs either Axes or Figure as parent")
+            raise TypeError(
+                "Legend needs either Axes or FigureBase as parent"
+            )
         self.parent = parent
 
         self._loc_used_default = loc is None

diff --git a/lib/matplotlib/cm.py b/lib/matplotlib/cm.py
index 38158db956..ea3764278c 100644
--- a/lib/matplotlib/cm.py
+++ b/lib/matplotlib/cm.py
@@ -146,6 +146,10 @@ class ColormapRegistry(Mapping):
                                "that was already in the registry.")
 
         self._cmaps[name] = cmap.copy()
+        # A colormap may be registered under a name different from its own.
+        # Store it using the registered name so subsequent default lookups work.
+        if self._cmaps[name].name != name:
+            self._cmaps[name].name = name
 
     def unregister(self, name):
         """
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
index 05922c93df..434bb54235 100644
--- a/lib/matplotlib/colors.py
+++ b/lib/matplotlib/colors.py
@@ -774,7 +774,7 @@ class Colormap:
         return cmapobject
 
     def __eq__(self, other):
-        if (not isinstance(other, Colormap) or self.name != other.name or
+        if (not isinstance(other, Colormap) or
                 self.colorbar_extend != other.colorbar_extend):
             return False
         # To compare lookup tables the Colormaps have to be initialized

diff --git a/doc/whatsnew/v0.12.1.rst b/doc/whatsnew/v0.12.1.rst
index 6ba57d5b..8c14a2f3 100644
--- a/doc/whatsnew/v0.12.1.rst
+++ b/doc/whatsnew/v0.12.1.rst
@@ -6,11 +6,13 @@ v0.12.1 (Unreleased)
 
 - |Feature| Added the :class:`objects.Perc` stat (:pr:`3063`).
 
-- |Feature| The :class:`Band` and :class:`Range` marks will now cover the full extent of the data if `min` / `max` variables are not explicitly assigned or added in a transform (:pr:`3056`).
+- |Feature| The :class:`objects.Band` and :class:`objects.Range` marks will now cover the full extent of the data if `min` / `max` variables are not explicitly assigned or added in a transform (:pr:`3056`).
 
-- |Enhancement| The :class:`Jitter` move now applies a small amount of jitter by default (:pr:`3066`).
+- |Enhancement| |Defaults| The :class:`objects.Jitter` move now applies a small amount of jitter by default (:pr:`3066`).
 
-- |Enhancement| Marks that sort along the orient axis (e.g. :class:`Line`) now use a stable algorithm (:pr:`3064`).
+- |Enhancement| |Defaults| Axes with a :class:`objects.Nominal` scale now appear like categorical axes in class seaborn, with fixed margins, no grid, and an inverted y axis (:pr:`3069`).
+
+- |Enhancement| Marks that sort along the orient axis (e.g. :class:`objects.Line`) now use a stable algorithm (:pr:`3064`).
 
 - |Fix| Make :class:`objects.PolyFit` robust to missing data (:pr:`3010`).
 
diff --git a/seaborn/_core/plot.py b/seaborn/_core/plot.py
index 4f0290a4..c834f7fd 100644
--- a/seaborn/_core/plot.py
+++ b/seaborn/_core/plot.py
@@ -25,7 +25,7 @@ from seaborn._marks.base import Mark
 from seaborn._stats.base import Stat
 from seaborn._core.data import PlotData
 from seaborn._core.moves import Move
-from seaborn._core.scales import Scale
+from seaborn._core.scales import Scale, Nominal
 from seaborn._core.subplots import Subplots
 from seaborn._core.groupby import GroupBy
 from seaborn._core.properties import PROPERTIES, Property
@@ -1238,7 +1238,6 @@ class Plotter:
             # This only affects us when sharing *paired* axes. This is a novel/niche
             # behavior, so we will raise rather than hack together a workaround.
             if axis is not None and Version(mpl.__version__) < Version("3.4.0"):
-                from seaborn._core.scales import Nominal
                 paired_axis = axis in p._pair_spec.get("structure", {})
                 cat_scale = isinstance(scale, Nominal)
                 ok_dim = {"x": "col", "y": "row"}[axis]
@@ -1631,10 +1630,11 @@ class Plotter:
             ax = sub["ax"]
             for axis in "xy":
                 axis_key = sub[axis]
+                axis_obj = getattr(ax, f"{axis}axis")
 
                 # Axis limits
                 if axis_key in p._limits:
-                    convert_units = getattr(ax, f"{axis}axis").convert_units
+                    convert_units = axis_obj.convert_units
                     a, b = p._limits[axis_key]
                     lo = a if a is None else convert_units(a)
                     hi = b if b is None else convert_units(b)
@@ -1644,6 +1644,17 @@ class Plotter:
                         hi = cast(float, hi) + 0.5
                     ax.set(**{f"{axis}lim": (lo, hi)})
 
+                # Nominal scale special-casing
+                if isinstance(self._scales.get(axis_key), Nominal):
+                    axis_obj.grid(False, which="both")
+                    if axis_key not in p._limits:
+                        nticks = len(axis_obj.get_major_ticks())
+                        lo, hi = -.5, nticks - .5
+                        if axis == "y":
+                            lo, hi = hi, lo
+                        set_lim = getattr(ax, f"set_{axis}lim")
+                        set_lim(lo, hi, auto=None)
+
         engine_default = None if p._target is not None else "tight"
         layout_engine = p._layout_spec.get("engine", engine_default)
         set_layout_engine(self._figure, layout_engine)

diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py
index d6f0da42..fae086e8 100644
--- a/xarray/core/dataset.py
+++ b/xarray/core/dataset.py
@@ -4768,7 +4768,10 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords):
                             # the former is often more efficient
                             reduce_dims = None
                         variables[name] = var.quantile(
-                            q, dim=reduce_dims, interpolation=interpolation
+                            q,
+                            dim=reduce_dims,
+                            interpolation=interpolation,
+                            keep_attrs=keep_attrs,
                         )
 
             else:
diff --git a/xarray/core/variable.py b/xarray/core/variable.py
index 2e9906ce..d3cb7add 100644
--- a/xarray/core/variable.py
+++ b/xarray/core/variable.py
@@ -1592,7 +1592,7 @@ class Variable(
         """
         return self.broadcast_equals(other, equiv=duck_array_ops.array_notnull_equiv)
 
-    def quantile(self, q, dim=None, interpolation="linear"):
+    def quantile(self, q, dim=None, interpolation="linear", keep_attrs=None):
         """Compute the qth quantile of the data along the specified dimension.
 
         Returns the qth quantiles(s) of the array elements.
@@ -1615,6 +1615,10 @@ class Variable(
                 * higher: ``j``.
                 * nearest: ``i`` or ``j``, whichever is nearest.
                 * midpoint: ``(i + j) / 2``.
+        keep_attrs : bool, optional
+            If True, the variable's attributes (`attrs`) will be copied from
+            the original object to the new one. If False (default), the new
+            object will be returned without attributes.
 
         Returns
         -------
@@ -1658,7 +1662,12 @@ class Variable(
         qs = np.nanpercentile(
             self.data, q * 100.0, axis=axis, interpolation=interpolation
         )
-        return Variable(new_dims, qs)
+
+        if keep_attrs is None:
+            keep_attrs = _get_keep_attrs(default=False)
+        attrs = self._attrs if keep_attrs else None
+
+        return Variable(new_dims, qs, attrs)
 
     def rank(self, dim, pct=False):
         """Ranks the data.

diff --git a/doc/whats-new.rst b/doc/whats-new.rst
index 5a9f2497..e69fbade 100644
--- a/doc/whats-new.rst
+++ b/doc/whats-new.rst
@@ -70,6 +70,8 @@ Bug fixes
   By `Justus Magin <https://github.com/keewis>`_.
 - :py:meth:`Dataset.rename`, :py:meth:`DataArray.rename` now check for conflicts with
   MultiIndex level names.
+- :py:meth:`Dataset.merge` no longer fails when passed a `DataArray` instead of a `Dataset` object.
+  By `Tom Nicholas <https://github.com/TomNicholas>`_.
 
 Documentation
 ~~~~~~~~~~~~~
diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py
index ac0a923d..d597ec8c 100644
--- a/xarray/core/dataset.py
+++ b/xarray/core/dataset.py
@@ -3604,6 +3604,7 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords):
             If any variables conflict (see ``compat``).
         """
         _check_inplace(inplace)
+        other = other.to_dataset() if isinstance(other, xr.DataArray) else other
         merge_result = dataset_merge_method(
             self,
             other,

diff --git a/.venv/pyvenv.cfg b/.venv/pyvenv.cfg
new file mode 100644
index 00000000..4760c1ff
--- /dev/null
+++ b/.venv/pyvenv.cfg
@@ -0,0 +1,3 @@
+home = /Library/Developer/CommandLineTools/usr/bin
+include-system-site-packages = false
+version = 3.9.6
diff --git a/doc/whats-new.rst b/doc/whats-new.rst
index cb0e9b65..fa561f91 100644
--- a/doc/whats-new.rst
+++ b/doc/whats-new.rst
@@ -23,6 +23,8 @@ New Features
 ~~~~~~~~~~~~
 - New top-level function :py:func:`cross`. (:issue:`3279`, :pull:`5365`).
   By `Jimmy Westling <https://github.com/illviljan>`_.
+- ``keep_attrs`` support for :py:func:`where` (:issue:`4141`, :issue:`4682`, :pull:`4687`).
+  By `Justus Magin <https://github.com/keewis>`_.
 
 - Enable the limit option for dask array in the following methods :py:meth:`DataArray.ffill`, :py:meth:`DataArray.bfill`, :py:meth:`Dataset.ffill` and :py:meth:`Dataset.bfill` (:issue:`6112`)
   By `Joseph Nowak <https://github.com/josephnowak>`_.
diff --git a/xarray/core/computation.py b/xarray/core/computation.py
index 9fe93c88..5e6340fe 100644
--- a/xarray/core/computation.py
+++ b/xarray/core/computation.py
@@ -1727,7 +1727,7 @@ def dot(*arrays, dims=None, **kwargs):
     return result.transpose(*all_dims, missing_dims="ignore")
 
 
-def where(cond, x, y):
+def where(cond, x, y, keep_attrs=None):
     """Return elements from `x` or `y` depending on `cond`.
 
     Performs xarray-like broadcasting across input arguments.
@@ -1743,6 +1743,8 @@ def where(cond, x, y):
         values to choose from where `cond` is True
     y : scalar, array, Variable, DataArray or Dataset
         values to choose from where `cond` is False
+    keep_attrs : bool or str or callable, optional
+        How to treat attrs. If True, keep the attrs of `x`.
 
     Returns
     -------
@@ -1808,6 +1810,14 @@ def where(cond, x, y):
     Dataset.where, DataArray.where :
         equivalent methods
     """
+    if keep_attrs is None:
+        keep_attrs = _get_keep_attrs(default=False)
+
+    if keep_attrs is True:
+        # keep the attributes of x, the second parameter, by default to
+        # be consistent with the `where` method of `DataArray` and `Dataset`
+        keep_attrs = lambda attrs, context: attrs[1]
+
     # alignment for three arguments is complicated, so don't support it yet
     return apply_ufunc(
         duck_array_ops.where,
@@ -1817,6 +1827,7 @@ def where(cond, x, y):
         join="exact",
         dataset_join="exact",
         dask="allowed",
+        keep_attrs=keep_attrs,
     )
 
 

diff --git a/pylint/lint/expand_modules.py b/pylint/lint/expand_modules.py
index 5cacc0371..289e1afce 100644
--- a/pylint/lint/expand_modules.py
+++ b/pylint/lint/expand_modules.py
@@ -52,6 +52,7 @@ def _is_ignored_file(
     ignore_list_re: list[Pattern[str]],
     ignore_list_paths_re: list[Pattern[str]],
 ) -> bool:
+    element = os.path.normpath(element)
     basename = os.path.basename(element)
     return (
         basename in ignore_list

diff --git a/changelog/7792.bugfix.rst b/changelog/7792.bugfix.rst
new file mode 100644
index 000000000..8f6563789
--- /dev/null
+++ b/changelog/7792.bugfix.rst
@@ -0,0 +1,5 @@
+Marks are now inherited according to the full MRO in test classes. Previously, if a test class inherited from two or more classes, only marks from the first super-class would apply.
+
+When inheriting marks from super-classes, marks from the sub-classes are now ordered before marks from the super-classes, in MRO order. Previously it was the reverse.
+
+When inheriting marks from super-classes, the `pytestmark` attribute of the sub-class now only contains the marks directly applied to it. Previously, it also contained marks from its super-classes. Please note that this attribute should not normally be accessed directly; use :func:`pytest.Node.iter_markers` instead.
diff --git a/src/_pytest/mark/structures.py b/src/_pytest/mark/structures.py
index 800a25c92..5186c9ea3 100644
--- a/src/_pytest/mark/structures.py
+++ b/src/_pytest/mark/structures.py
@@ -355,12 +355,35 @@ class MarkDecorator:
         return self.with_args(*args, **kwargs)
 
 
-def get_unpacked_marks(obj: object) -> Iterable[Mark]:
-    """Obtain the unpacked marks that are stored on an object."""
-    mark_list = getattr(obj, "pytestmark", [])
-    if not isinstance(mark_list, list):
-        mark_list = [mark_list]
-    return normalize_mark_list(mark_list)
+def get_unpacked_marks(
+    obj: Union[object, type],
+    *,
+    consider_mro: bool = True,
+) -> List[Mark]:
+    """Obtain the unpacked marks that are stored on an object.
+
+    If obj is a class and consider_mro is true, return marks applied to
+    this class and all of its super-classes in MRO order. If consider_mro
+    is false, only return marks applied directly to this class.
+    """
+    if isinstance(obj, type):
+        if not consider_mro:
+            mark_lists = [obj.__dict__.get("pytestmark", [])]
+        else:
+            mark_lists = [x.__dict__.get("pytestmark", []) for x in obj.__mro__]
+        mark_list = []
+        for item in mark_lists:
+            if isinstance(item, list):
+                mark_list.extend(item)
+            else:
+                mark_list.append(item)
+    else:
+        mark_attribute = getattr(obj, "pytestmark", [])
+        if isinstance(mark_attribute, list):
+            mark_list = mark_attribute
+        else:
+            mark_list = [mark_attribute]
+    return list(normalize_mark_list(mark_list))
 
 
 def normalize_mark_list(
@@ -388,7 +411,7 @@ def store_mark(obj, mark: Mark) -> None:
     assert isinstance(mark, Mark), mark
     # Always reassign name to avoid updating pytestmark in a reference that
     # was only borrowed.
-    obj.pytestmark = [*get_unpacked_marks(obj), mark]
+    obj.pytestmark = [*get_unpacked_marks(obj, consider_mro=False), mark]
 
 
 # Typing for builtin pytest marks. This is cheating; it gives builtin marks

diff --git a/src/_pytest/logging.py b/src/_pytest/logging.py
index 11031f2f2..6c422647d 100644
--- a/src/_pytest/logging.py
+++ b/src/_pytest/logging.py
@@ -345,6 +345,7 @@ class LogCaptureFixture:
         """Creates a new funcarg."""
         self._item = item
         # dict of log name -> log level
+        self._initial_handler_level = None  # type: Optional[int]
         self._initial_logger_levels = {}  # type: Dict[Optional[str], int]
 
     def _finalize(self) -> None:
@@ -353,6 +354,8 @@ class LogCaptureFixture:
         This restores the log levels changed by :meth:`set_level`.
         """
         # restore log levels
+        if self._initial_handler_level is not None:
+            self.handler.setLevel(self._initial_handler_level)
         for logger_name, level in self._initial_logger_levels.items():
             logger = logging.getLogger(logger_name)
             logger.setLevel(level)
@@ -434,6 +437,8 @@ class LogCaptureFixture:
         # save the original log-level to restore it during teardown
         self._initial_logger_levels.setdefault(logger, logger_obj.level)
         logger_obj.setLevel(level)
+        if self._initial_handler_level is None:
+            self._initial_handler_level = self.handler.level
         self.handler.setLevel(level)
 
     @contextmanager

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst
index 7bc4389e51..f4cd3bcbe3 100644
--- a/doc/whats_new/v0.21.rst
+++ b/doc/whats_new/v0.21.rst
@@ -208,6 +208,11 @@ Support for Python 3.4 and below has been officially dropped.
   :func:`~model_selection.validation_curve` only the latter is required.
   :issue:`12613` and :issue:`12669` by :user:`Marc Torrellas <marctorrellas>`.
 
+- |Fix| Fixed a bug where :class:`model_selection.StratifiedKFold`
+  shuffles each class's samples with the same ``random_state``,
+  making ``shuffle=True`` ineffective.
+  :issue:`13124` by :user:`Hanmin Qin <qinhanmin2014>`.
+
 :mod:`sklearn.neighbors`
 ........................
 
diff --git a/sklearn/model_selection/_split.py b/sklearn/model_selection/_split.py
index 24394f8691..0c09ff3b05 100644
--- a/sklearn/model_selection/_split.py
+++ b/sklearn/model_selection/_split.py
@@ -576,8 +576,7 @@ class StratifiedKFold(_BaseKFold):
             ``n_splits`` default value will change from 3 to 5 in v0.22.
 
     shuffle : boolean, optional
-        Whether to shuffle each stratification of the data before splitting
-        into batches.
+        Whether to shuffle each class's samples before splitting into batches.
 
     random_state : int, RandomState instance or None, optional, default=None
         If int, random_state is the seed used by the random number generator;
@@ -620,7 +619,7 @@ class StratifiedKFold(_BaseKFold):
         super().__init__(n_splits, shuffle, random_state)
 
     def _make_test_folds(self, X, y=None):
-        rng = self.random_state
+        rng = check_random_state(self.random_state)
         y = np.asarray(y)
         type_of_target_y = type_of_target(y)
         allowed_target_types = ('binary', 'multiclass')

diff --git a/sklearn/mixture/base.py b/sklearn/mixture/base.py
index bd34333c06..8920bef181 100644
--- a/sklearn/mixture/base.py
+++ b/sklearn/mixture/base.py
@@ -257,11 +257,6 @@ class BaseMixture(DensityMixin, BaseEstimator, metaclass=ABCMeta):
                 best_params = self._get_parameters()
                 best_n_iter = n_iter
 
-        # Always do a final e-step to guarantee that the labels returned by
-        # fit_predict(X) are always consistent with fit(X).predict(X)
-        # for any value of max_iter and tol (and any random_state).
-        _, log_resp = self._e_step(X)
-
         if not self.converged_:
             warnings.warn('Initialization %d did not converge. '
                           'Try different init parameters, '
@@ -273,6 +268,11 @@ class BaseMixture(DensityMixin, BaseEstimator, metaclass=ABCMeta):
         self.n_iter_ = best_n_iter
         self.lower_bound_ = max_lower_bound
 
+        # Always do a final e-step to guarantee that the labels returned by
+        # fit_predict(X) are always consistent with fit(X).predict(X)
+        # for any value of max_iter and tol (and any random_state).
+        _, log_resp = self._e_step(X)
+
         return log_resp.argmax(axis=1)
 
     def _e_step(self, X):

diff --git a/sklearn/utils/_show_versions.py b/sklearn/utils/_show_versions.py
index e5d3141bf0..ecba9ec68b 100644
--- a/sklearn/utils/_show_versions.py
+++ b/sklearn/utils/_show_versions.py
@@ -48,6 +48,7 @@ def _get_deps_info():
         "Cython",
         "pandas",
         "matplotlib",
+        "joblib",
     ]
 
     def get_version(module):

diff --git a/doc/whats_new/v1.3.rst b/doc/whats_new/v1.3.rst
index 51b4214145..e66942118a 100644
--- a/doc/whats_new/v1.3.rst
+++ b/doc/whats_new/v1.3.rst
@@ -146,6 +146,9 @@ Changelog
 - |Enhancement| All selectors in :mod:`sklearn.feature_selection` will preserve
   a DataFrame's dtype when transformed. :pr:`25102` by `Thomas Fan`_.
 
+- |Fix| :class:`feature_selection.SequentialFeatureSelector`'s `cv` parameter
+  now supports generators. :pr:`25973` by `Yao Xiao <Charlie-XIAO>`_.
+
 :mod:`sklearn.base`
 ...................
 
diff --git a/sklearn/feature_selection/_sequential.py b/sklearn/feature_selection/_sequential.py
index e983c55de7..2498cd53b3 100644
--- a/sklearn/feature_selection/_sequential.py
+++ b/sklearn/feature_selection/_sequential.py
@@ -8,12 +8,12 @@ import numpy as np
 import warnings
 
 from ._base import SelectorMixin
-from ..base import BaseEstimator, MetaEstimatorMixin, clone
+from ..base import BaseEstimator, MetaEstimatorMixin, clone, is_classifier
 from ..utils._param_validation import HasMethods, Hidden, Interval, StrOptions
 from ..utils._param_validation import RealNotInt
 from ..utils._tags import _safe_tags
 from ..utils.validation import check_is_fitted
-from ..model_selection import cross_val_score
+from ..model_selection import cross_val_score, check_cv
 from ..metrics import get_scorer_names
 
 
@@ -259,6 +259,8 @@ class SequentialFeatureSelector(SelectorMixin, MetaEstimatorMixin, BaseEstimator
         if self.tol is not None and self.tol < 0 and self.direction == "forward":
             raise ValueError("tol must be positive when doing forward selection")
 
+        cv = check_cv(self.cv, y, classifier=is_classifier(self.estimator))
+
         cloned_estimator = clone(self.estimator)
 
         # the current mask corresponds to the set of features:
@@ -275,7 +277,7 @@ class SequentialFeatureSelector(SelectorMixin, MetaEstimatorMixin, BaseEstimator
         is_auto_select = self.tol is not None and self.n_features_to_select == "auto"
         for _ in range(n_iterations):
             new_feature_idx, new_score = self._get_best_new_feature_score(
-                cloned_estimator, X, y, current_mask
+                cloned_estimator, X, y, cv, current_mask
             )
             if is_auto_select and ((new_score - old_score) < self.tol):
                 break
@@ -291,7 +293,7 @@ class SequentialFeatureSelector(SelectorMixin, MetaEstimatorMixin, BaseEstimator
 
         return self
 
-    def _get_best_new_feature_score(self, estimator, X, y, current_mask):
+    def _get_best_new_feature_score(self, estimator, X, y, cv, current_mask):
         # Return the best new feature and its score to add to the current_mask,
         # i.e. return the best new feature and its score to add (resp. remove)
         # when doing forward selection (resp. backward selection).
@@ -309,7 +311,7 @@ class SequentialFeatureSelector(SelectorMixin, MetaEstimatorMixin, BaseEstimator
                 estimator,
                 X_new,
                 y,
-                cv=self.cv,
+                cv=cv,
                 scoring=self.scoring,
                 n_jobs=self.n_jobs,
             ).mean()

diff --git a/sklearn/compose/_column_transformer.py b/sklearn/compose/_column_transformer.py
index 4eddd12b1b..8fa7c83b2f 100644
--- a/sklearn/compose/_column_transformer.py
+++ b/sklearn/compose/_column_transformer.py
@@ -275,8 +275,8 @@ class ColumnTransformer(TransformerMixin, _BaseComposition):
     def set_output(self, *, transform=None):
         """Set the output container when `"transform"` and `"fit_transform"` are called.
 
-        Calling `set_output` will set the output of all estimators in `transformers`
-        and `transformers_`.
+        Calling `set_output` will set the output of all estimators in
+        `transformers`, `transformers_`, and `remainder`.
 
         Parameters
         ----------
@@ -296,7 +296,9 @@ class ColumnTransformer(TransformerMixin, _BaseComposition):
         transformers = (
             trans
             for _, trans, _ in chain(
-                self.transformers, getattr(self, "transformers_", [])
+                self.transformers,
+                getattr(self, "transformers_", []),
+                [("remainder", self.remainder, None)],
             )
             if trans not in {"passthrough", "drop"}
         )

Bu görevde değişiklik üretilmedi; bağımsız değerlendirme bu yüzden sonuç vermedi.

diff --git a/sphinx/domains/python.py b/sphinx/domains/python.py
index 893bb0a22..07a66fe22 100644
--- a/sphinx/domains/python.py
+++ b/sphinx/domains/python.py
@@ -71,8 +71,13 @@ pairindextypes = {
 def _parse_annotation(annotation: str) -> List[Node]:
     """Parse type annotation."""
     def make_xref(text: str) -> addnodes.pending_xref:
+        if text == 'None':
+            reftype = 'obj'
+        else:
+            reftype = 'class'
+
         return pending_xref('', nodes.Text(text),
-                            refdomain='py', reftype='class', reftarget=text)
+                            refdomain='py', reftype=reftype, reftarget=text)
 
     def unparse(node: ast.AST) -> List[Node]:
         if isinstance(node, ast.Attribute):

diff --git a/CHANGES b/CHANGES
index da8580fe6..36caf8f77 100644
--- a/CHANGES
+++ b/CHANGES
@@ -30,6 +30,7 @@ Features added
   allow typehints to be included both in the signature and description
 * #4257: autodoc: Add :confval:`autodoc_class_signature` to separate the class
   entry and the definition of ``__init__()`` method
+* #8061, #9218: autodoc: Support variable comment for alias classes
 * #3257: autosummary: Support instance attributes for classes
 * #9129: html search: Show search summaries when html_copy_source = False
 * #9120: html theme: Eliminate prompt characters of code-block from copyable
diff --git a/sphinx/ext/autodoc/__init__.py b/sphinx/ext/autodoc/__init__.py
index 1f4c98284..18fb0c92e 100644
--- a/sphinx/ext/autodoc/__init__.py
+++ b/sphinx/ext/autodoc/__init__.py
@@ -1676,7 +1676,11 @@ class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type:
     def get_doc(self, ignore: int = None) -> Optional[List[List[str]]]:
         if self.doc_as_attr:
             # Don't show the docstring of the class when it is an alias.
-            return None
+            comment = self.get_variable_comment()
+            if comment:
+                return []
+            else:
+                return None
 
         lines = getattr(self, '_new_docstrings', None)
         if lines is not None:
@@ -1721,9 +1725,18 @@ class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type:
         tab_width = self.directive.state.document.settings.tab_width
         return [prepare_docstring(docstring, ignore, tab_width) for docstring in docstrings]
 
+    def get_variable_comment(self) -> Optional[List[str]]:
+        try:
+            key = ('', '.'.join(self.objpath))
+            analyzer = ModuleAnalyzer.for_module(self.get_real_modname())
+            analyzer.analyze()
+            return list(self.analyzer.attr_docs.get(key, []))
+        except PycodeError:
+            return None
+
     def add_content(self, more_content: Optional[StringList], no_docstring: bool = False
                     ) -> None:
-        if self.doc_as_attr:
+        if self.doc_as_attr and not self.get_variable_comment():
             try:
                 more_content = StringList([_('alias of %s') % restify(self.object)], source='')
             except AttributeError:

diff --git a/CHANGES b/CHANGES
index e094cd79a..db57819c2 100644
--- a/CHANGES
+++ b/CHANGES
@@ -39,6 +39,7 @@ Features added
   text
 * #9176: i18n: Emit a debug message if message catalog file not found under
   :confval:`locale_dirs`
+* #1874: py domain: Support union types using ``|`` in info-field-list
 * #9097: Optimize the paralell build
 * #9131: Add :confval:`nitpick_ignore_regex` to ignore nitpicky warnings using
   regular expressions
diff --git a/sphinx/domains/python.py b/sphinx/domains/python.py
index 7d39d80ed..ba021b36b 100644
--- a/sphinx/domains/python.py
+++ b/sphinx/domains/python.py
@@ -304,7 +304,7 @@ class PyXrefMixin:
     def make_xrefs(self, rolename: str, domain: str, target: str,
                    innernode: Type[TextlikeNode] = nodes.emphasis,
                    contnode: Node = None, env: BuildEnvironment = None) -> List[Node]:
-        delims = r'(\s*[\[\]\(\),](?:\s*or\s)?\s*|\s+or\s+|\.\.\.)'
+        delims = r'(\s*[\[\]\(\),](?:\s*or\s)?\s*|\s+or\s+|\s*\|\s*|\.\.\.)'
         delims_re = re.compile(delims)
         sub_targets = re.split(delims, target)
 

diff --git a/sympy/physics/vector/vector.py b/sympy/physics/vector/vector.py
index a048ee57f1..8849119218 100644
--- a/sympy/physics/vector/vector.py
+++ b/sympy/physics/vector/vector.py
@@ -57,6 +57,8 @@ def __hash__(self):
 
     def __add__(self, other):
         """The add operator for Vector. """
+        if other == 0:
+            return self
         other = _check_vector(other)
         return Vector(self.args + other.args)
 

diff --git a/sympy/printing/pycode.py b/sympy/printing/pycode.py
index a3f0310735..0f5cd6b75c 100644
--- a/sympy/printing/pycode.py
+++ b/sympy/printing/pycode.py
@@ -357,6 +357,11 @@ def _print_Not(self, expr):
         PREC = precedence(expr)
         return self._operators['not'] + self.parenthesize(expr.args[0], PREC)
 
+    def _print_Indexed(self, expr):
+        base, *index = expr.args
+        return "{}[{}]".format(
+            str(base), ", ".join(self._print(ind) for ind in index))
+
 
 for k in PythonCodePrinter._kf:
     setattr(PythonCodePrinter, '_print_%s' % k, _print_known_func)

diff --git a/sympy/polys/matrices/normalforms.py b/sympy/polys/matrices/normalforms.py
index 30f5534b08..e2c0546857 100644
--- a/sympy/polys/matrices/normalforms.py
+++ b/sympy/polys/matrices/normalforms.py
@@ -205,16 +205,19 @@ def _hermite_normal_form(A):
     if not A.domain.is_ZZ:
         raise DMDomainError('Matrix must be over domain ZZ.')
     # We work one row at a time, starting from the bottom row, and working our
-    # way up. The total number of rows we will consider is min(m, n), where
-    # A is an m x n matrix.
+    # way up.
     m, n = A.shape
-    rows = min(m, n)
     A = A.to_dense().rep.copy()
     # Our goal is to put pivot entries in the rightmost columns.
     # Invariant: Before processing each row, k should be the index of the
     # leftmost column in which we have so far put a pivot.
     k = n
-    for i in range(m - 1, m - 1 - rows, -1):
+    for i in range(m - 1, -1, -1):
+        if k == 0:
+            # This case can arise when n < m and we've already found n pivots.
+            # We don't need to consider any more rows, because this is already
+            # the maximum possible number of pivots.
+            break
         k -= 1
         # k now points to the column in which we want to put a pivot.
         # We want zeros in all entries to the left of the pivot column.