Merge remote-tracking branch 'upstream/main'

Author: dan-mm

django/contrib/admin/templates/admin/change_list.html

@@ -74,7 +74,7 @@
       </div>
       {% block filters %}
         {% if cl.has_filters %}
-          <nav id="changelist-filter" aria-labelledby="changelist-filter-header">
+          <search id="changelist-filter" aria-labelledby="changelist-filter-header">
             <h2 id="changelist-filter-header">{% translate 'Filter' %}</h2>
             {% if cl.is_facets_optional or cl.has_active_filters %}<div id="changelist-filter-extra-actions">
               {% if cl.is_facets_optional %}<h3>
@@ -86,7 +86,7 @@ <h2 id="changelist-filter-header">{% translate 'Filter' %}</h2>
               </h3>{% endif %}
             </div>{% endif %}
             {% for spec in cl.filter_specs %}{% admin_list_filter cl spec %}{% endfor %}
-          </nav>
+          </search>
         {% endif %}
       {% endblock %}
     </div>

django/contrib/admin/templates/admin/search_form.html

@@ -1,6 +1,8 @@
 {% load i18n static %}
 {% if cl.search_fields %}
-<div id="toolbar"><form id="changelist-search" method="get" role="search">
+<div id="toolbar">
+<h2 id="changelist-search-form" class="visually-hidden">{% blocktranslate with name=cl.opts.verbose_name_plural %}Search {{ name }}{% endblocktranslate %}</h2>
+<form id="changelist-search" method="get" role="search" aria-labelledby="changelist-search-form">
 <div><!-- DIV needed for valid HTML -->
 <label for="searchbar"><img src="{% static "admin/img/search.svg" %}" alt="Search"></label>
 <input type="text" size="40" name="{{ search_var }}" value="{{ cl.query }}" id="searchbar"{% if cl.search_help_text %} aria-describedby="searchbar_helptext"{% endif %}>

django/contrib/humanize/templatetags/humanize.py

@@ -1,6 +1,6 @@
 import re
 from datetime import UTC, date, datetime
-from decimal import Decimal
+from decimal import Decimal, InvalidOperation
 
 from django import template
 from django.template import defaultfilters
@@ -66,14 +66,15 @@ def ordinal(value):
 @register.filter(is_safe=True)
 def intcomma(value, use_l10n=True):
     """
-    Convert an integer to a string containing commas every three digits.
-    For example, 3000 becomes '3,000' and 45000 becomes '45,000'.
+    Convert an integer or float (or a string representation of either) to a
+    string containing commas every three digits. Format localization is
+    respected. For example, 3000 becomes '3,000' and 45000 becomes '45,000'.
     """
     if use_l10n:
         try:
             if not isinstance(value, (float, Decimal)):
-                value = int(value)
-        except (TypeError, ValueError):
+                value = Decimal(value)
+        except (TypeError, ValueError, InvalidOperation):
             return intcomma(value, False)
         else:
             return number_format(value, use_l10n=True, force_grouping=True)

django/db/backends/base/features.py

@@ -347,6 +347,8 @@ class BaseDatabaseFeatures:
     json_key_contains_list_matching_requires_list = False
     # Does the backend support JSONObject() database function?
     has_json_object_function = True
+    # Does the backend support negative JSON array indexing?
+    supports_json_negative_indexing = True
 
     # Does the backend support column collations?
     supports_collation_on_charfield = True

django/db/backends/base/operations.py

@@ -792,3 +792,32 @@ def prepare_join_on_clause(self, lhs_table, lhs_field, rhs_table, rhs_field):
     def format_debug_sql(self, sql):
         # Hook for backends (e.g. NoSQL) to customize formatting.
         return sqlparse.format(sql, reindent=True, keyword_case="upper")
+
+    def format_json_path_numeric_index(self, num):
+        """
+        Hook for backends to customize array indexing in JSON paths.
+        """
+        return "[%s]" % num
+
+    def compile_json_path(self, key_transforms, include_root=True):
+        """
+        Hook for backends to customize all aspects of JSON path construction.
+        """
+        path = ["$"] if include_root else []
+        for key_transform in key_transforms:
+            try:
+                num = int(key_transform)
+            except ValueError:  # Non-integer.
+                path.append(".")
+                path.append(json.dumps(key_transform))
+            else:
+                if (
+                    num < 0
+                    and not self.connection.features.supports_json_negative_indexing
+                ):
+                    raise NotSupportedError(
+                        "Using negative JSON array indices is not supported on this "
+                        "database backend."
+                    )
+                path.append(self.format_json_path_numeric_index(num))
+        return "".join(path)

django/db/backends/mysql/features.py

@@ -58,6 +58,8 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     supports_stored_generated_columns = True
     supports_virtual_generated_columns = True
 
+    supports_json_negative_indexing = False
+
     @cached_property
     def minimum_database_version(self):
         if self.connection.mysql_is_mariadb:

django/db/backends/oracle/features.py

@@ -73,6 +73,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     requires_compound_order_by_subquery = True
     allows_multiple_constraints_on_same_fields = False
     supports_json_field_contains = False
+    supports_json_negative_indexing = False
     supports_collation_on_textfield = False
     test_now_utc_template = "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'"
     django_test_expected_failures = {

django/db/backends/sqlite3/operations.py

@@ -441,3 +441,6 @@ def on_conflict_suffix_sql(self, fields, on_conflict, update_fields, unique_fiel
 
     def force_group_by(self):
         return ["GROUP BY TRUE"] if Database.sqlite_version_info < (3, 39) else []
+
+    def format_json_path_numeric_index(self, num):
+        return "[#%s]" % num if num < 0 else super().format_json_path_numeric_index(num)

django/db/migrations/serializer.py

@@ -93,19 +93,29 @@ def serialize(self):
         return repr(self.value), {"from decimal import Decimal"}
 
 
-class DeconstructableSerializer(BaseSerializer):
+class DeconstructibleSerializer(BaseSerializer):
     @staticmethod
     def serialize_deconstructed(path, args, kwargs):
-        name, imports = DeconstructableSerializer._serialize_path(path)
+        name, imports = DeconstructibleSerializer._serialize_path(path)
         strings = []
         for arg in args:
             arg_string, arg_imports = serializer_factory(arg).serialize()
             strings.append(arg_string)
             imports.update(arg_imports)
+        non_ident_kwargs = {}
         for kw, arg in sorted(kwargs.items()):
-            arg_string, arg_imports = serializer_factory(arg).serialize()
-            imports.update(arg_imports)
-            strings.append("%s=%s" % (kw, arg_string))
+            if kw.isidentifier():
+                arg_string, arg_imports = serializer_factory(arg).serialize()
+                imports.update(arg_imports)
+                strings.append("%s=%s" % (kw, arg_string))
+            else:
+                non_ident_kwargs[kw] = arg
+        if non_ident_kwargs:
+            # Serialize non-identifier keyword arguments as a dict.
+            kw_string, kw_imports = serializer_factory(non_ident_kwargs).serialize()
+            strings.append(f"**{kw_string}")
+            imports.update(kw_imports)
+
         return "%s(%s)" % (name, ", ".join(strings)), imports
 
     @staticmethod
@@ -197,23 +207,11 @@ def serialize(self):
 
 class FunctoolsPartialSerializer(BaseSerializer):
     def serialize(self):
-        # Serialize functools.partial() arguments
-        func_string, func_imports = serializer_factory(self.value.func).serialize()
-        args_string, args_imports = serializer_factory(self.value.args).serialize()
-        keywords_string, keywords_imports = serializer_factory(
-            self.value.keywords
-        ).serialize()
-        # Add any imports needed by arguments
-        imports = {"import functools", *func_imports, *args_imports, *keywords_imports}
-        return (
-            "functools.%s(%s, *%s, **%s)"
-            % (
-                self.value.__class__.__name__,
-                func_string,
-                args_string,
-                keywords_string,
-            ),
-            imports,
+        partial_name = self.value.__class__.__name__
+        return DeconstructibleSerializer.serialize_deconstructed(
+            f"functools.{partial_name}",
+            (self.value.func, *self.value.args),
+            self.value.keywords,
         )
 
 
@@ -231,13 +229,13 @@ def serialize(self):
         return value % (", ".join(strings)), imports
 
 
-class ModelFieldSerializer(DeconstructableSerializer):
+class ModelFieldSerializer(DeconstructibleSerializer):
     def serialize(self):
         attr_name, path, args, kwargs = self.value.deconstruct()
         return self.serialize_deconstructed(path, args, kwargs)
 
 
-class ModelManagerSerializer(DeconstructableSerializer):
+class ModelManagerSerializer(DeconstructibleSerializer):
     def serialize(self):
         as_manager, manager_path, qs_path, args, kwargs = self.value.deconstruct()
         if as_manager:
@@ -397,7 +395,7 @@ def serializer_factory(value):
         return TypeSerializer(value)
     # Anything that knows how to deconstruct itself.
     if hasattr(value, "deconstruct"):
-        return DeconstructableSerializer(value)
+        return DeconstructibleSerializer(value)
     for type_, serializer_cls in Serializer._registry.items():
         if isinstance(value, type_):
             return serializer_cls(value)

django/db/models/base.py

@@ -2115,93 +2115,13 @@ def _check_unique_together(cls):
 
     @classmethod
     def _check_indexes(cls, databases):
-        """Check fields, names, and conditions of indexes."""
         errors = []
-        references = set()
-        for index in cls._meta.indexes:
-            # Index name can't start with an underscore or a number, restricted
-            # for cross-database compatibility with Oracle.
-            if index.name[0] == "_" or index.name[0].isdigit():
-                errors.append(
-                    checks.Error(
-                        "The index name '%s' cannot start with an underscore "
-                        "or a number." % index.name,
-                        obj=cls,
-                        id="models.E033",
-                    ),
-                )
-            if len(index.name) > index.max_name_length:
-                errors.append(
-                    checks.Error(
-                        "The index name '%s' cannot be longer than %d "
-                        "characters." % (index.name, index.max_name_length),
-                        obj=cls,
-                        id="models.E034",
-                    ),
-                )
-            if index.contains_expressions:
-                for expression in index.expressions:
-                    references.update(
-                        ref[0] for ref in cls._get_expr_references(expression)
-                    )
         for db in databases:
             if not router.allow_migrate_model(db, cls):
                 continue
             connection = connections[db]
-            if not (
-                connection.features.supports_partial_indexes
-                or "supports_partial_indexes" in cls._meta.required_db_features
-            ) and any(index.condition is not None for index in cls._meta.indexes):
-                errors.append(
-                    checks.Warning(
-                        "%s does not support indexes with conditions."
-                        % connection.display_name,
-                        hint=(
-                            "Conditions will be ignored. Silence this warning "
-                            "if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W037",
-                    )
-                )
-            if not (
-                connection.features.supports_covering_indexes
-                or "supports_covering_indexes" in cls._meta.required_db_features
-            ) and any(index.include for index in cls._meta.indexes):
-                errors.append(
-                    checks.Warning(
-                        "%s does not support indexes with non-key columns."
-                        % connection.display_name,
-                        hint=(
-                            "Non-key columns will be ignored. Silence this "
-                            "warning if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W040",
-                    )
-                )
-            if not (
-                connection.features.supports_expression_indexes
-                or "supports_expression_indexes" in cls._meta.required_db_features
-            ) and any(index.contains_expressions for index in cls._meta.indexes):
-                errors.append(
-                    checks.Warning(
-                        "%s does not support indexes on expressions."
-                        % connection.display_name,
-                        hint=(
-                            "An index won't be created. Silence this warning "
-                            "if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W043",
-                    )
-                )
-        fields = [
-            field for index in cls._meta.indexes for field, _ in index.fields_orders
-        ]
-        fields += [include for index in cls._meta.indexes for include in index.include]
-        fields += references
-        errors.extend(cls._check_local_fields(fields, "indexes"))
+            for index in cls._meta.indexes:
+                errors.extend(index.check(cls, connection))
         return errors
 
     @classmethod