feat!: remove deprecated "descendant_count" completely

Author: bradenmacdonald

src/openedx_tagging/data.py

@@ -21,7 +21,6 @@ class TagData(TypedDict):
     value: str
     external_id: str | None
     child_count: int
-    descendant_count: int  # Deprecated; do not use.
     depth: int
     parent_value: str | None
     # Note: usage_count may or may not be present, depending on the request.

src/openedx_tagging/models/base.py

@@ -173,7 +173,7 @@ def descendant_count(self) -> int:
             ).count()
         return 0
 
-    def save(self, *args, **kwargs):
+    def save(self, *args, **kwargs) -> None:
         """
         Compute and persist depth and lineage before saving, then cascade any changes to descendants.
         """
@@ -187,8 +187,8 @@ def save(self, *args, **kwargs):
             self.lineage = self.value + "\t"
         else:
             if Tag.parent.is_cached(self):  # pylint: disable=no-member
-                parent_depth = self.parent.depth
-                parent_lineage = self.parent.lineage
+                parent_depth = self.parent.depth  # type: ignore[union-attr]
+                parent_lineage = self.parent.lineage  # type: ignore[union-attr]
             else:
                 parent_vals = Tag.objects.values("depth", "lineage").get(pk=self.parent_id)
                 parent_depth = parent_vals["depth"]
@@ -216,7 +216,9 @@ def save(self, *args, **kwargs):
             }
             if depth_delta != 0:
                 update_kwargs["depth"] = F("depth") + depth_delta
-            self.taxonomy.tag_set.filter(lineage__startswith=old_values["lineage"]).exclude(pk=self.pk).update(
+            self.taxonomy.tag_set.filter(  # type: ignore[union-attr]
+                lineage__startswith=old_values["lineage"]
+            ).exclude(pk=self.pk).update(
                 **update_kwargs
             )
 
@@ -492,7 +494,6 @@ def _get_filtered_tags_free_text(
         qs = qs.annotate(
             depth=Value(0),
             child_count=Value(0),
-            descendant_count=Value(0),
             external_id=Value(None, output_field=models.CharField()),
             parent_value=Value(None, output_field=models.CharField()),
             _id=Value(None, output_field=models.CharField()),
@@ -524,13 +525,11 @@ def _get_filtered_tags_one_level(
             qs = self.tag_set.filter(parent=None)
             qs = qs.annotate(parent_value=Value(None, output_field=models.CharField()))
         qs = qs.annotate(child_count=models.Count("children", distinct=True))  # type: ignore[no-redef]
-        # Add the deprecated "descendant_count field". For now it's just the same as child_count.
-        qs = qs.annotate(descendant_count=F("child_count"))
         # Filter by search term:
         if search_term:
             qs = qs.filter(value__icontains=search_term)
         qs = qs.annotate(_id=F("id"))  # ID has an underscore to encourage use of 'value' rather than this internal ID
-        qs = qs.values("value", "child_count", "descendant_count", "depth", "parent_value", "external_id", "_id")
+        qs = qs.values("value", "child_count", "depth", "parent_value", "external_id", "_id")
         qs = qs.order_by("value")
         if include_counts:
             # We need to include the count of how many times this tag is used to tag objects.
@@ -605,15 +604,13 @@ def _get_filtered_tags_deep(
             .order_by()
             .annotate(count=models.Func(F("id"), function="Count"))
         )
-        qs = initial_qs.annotate(child_count=models.Subquery(child_count_sq.values("count")))
-        # Add the deprecated "descendant_count" field. For now it just is the same as child_count.
-        qs = qs.annotate(descendant_count=F("child_count"))
+        qs = initial_qs.annotate(child_count=models.Subquery(child_count_sq.values("count")))  # type: ignore[no-redef]
 
         # Add the parent value
         qs = qs.annotate(parent_value=F("parent__value"))
         qs = qs.annotate(_id=F("id"))  # ID has an underscore to encourage use of 'value' rather than this internal ID
         qs = qs.values(  # type: ignore[assignment]
-            "value", "child_count", "descendant_count", "depth", "parent_value", "external_id", "_id"
+            "value", "child_count", "depth", "parent_value", "external_id", "_id"
         )
         # lineage is a case-insensitive column storing "Root\tParent\t...\tThisValue\t", so
         # ordering by it gives the tree sort order that we want.

src/openedx_tagging/rest_api/v1/serializers.py

@@ -226,7 +226,6 @@ class TagDataSerializer(UserPermissionsSerializerMixin, serializers.Serializer):
     value = serializers.CharField()
     external_id = serializers.CharField(allow_null=True)
     child_count = serializers.IntegerField()
-    descendant_count = serializers.IntegerField()  # deprecated
     depth = serializers.IntegerField()
     parent_value = serializers.CharField(allow_null=True)
     usage_count = serializers.IntegerField(required=False)

tests/openedx_tagging/test_models.py

@@ -329,9 +329,9 @@ def test_get_root(self) -> None:
             del r["_id"]  # Remove the internal database IDs; they aren't interesting here and a other tests check them
         assert result == [
             # These are the root tags, in alphabetical order:
-            {"value": "Archaea", "child_count": 3, "descendant_count": 3, **common_fields},
-            {"value": "Bacteria", "child_count": 2, "descendant_count": 2, **common_fields},
-            {"value": "Eukaryota", "child_count": 5, "descendant_count": 5, **common_fields},
+            {"value": "Archaea", "child_count": 3, **common_fields},
+            {"value": "Bacteria", "child_count": 2, **common_fields},
+            {"value": "Eukaryota", "child_count": 5, **common_fields},
         ]
 
     def test_get_child_tags_one_level(self) -> None:
@@ -345,11 +345,11 @@ def test_get_child_tags_one_level(self) -> None:
             del r["_id"]  # Remove the internal database IDs; they aren't interesting here and a other tests check them
         assert result == [
             # These are the Eukaryota tags, in alphabetical order:
-            {"value": "Animalia", "child_count": 7, "descendant_count": 7, **common_fields},
-            {"value": "Fungi", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Monera", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Plantae", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Protista", "child_count": 0, "descendant_count": 0, **common_fields},
+            {"value": "Animalia", "child_count": 7, **common_fields},
+            {"value": "Fungi", "child_count": 0, **common_fields},
+            {"value": "Monera", "child_count": 0, **common_fields},
+            {"value": "Plantae", "child_count": 0, **common_fields},
+            {"value": "Protista", "child_count": 0, **common_fields},
         ]
 
     def test_get_grandchild_tags_one_level(self) -> None:
@@ -363,13 +363,13 @@ def test_get_grandchild_tags_one_level(self) -> None:
             del r["_id"]  # Remove the internal database IDs; they aren't interesting here and a other tests check them
         assert result == [
             # These are the Eukaryota tags, in alphabetical order:
-            {"value": "Arthropoda", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Chordata", "child_count": 1, "descendant_count": 1, **common_fields},
-            {"value": "Cnidaria", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Ctenophora", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Gastrotrich", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Placozoa", "child_count": 0, "descendant_count": 0, **common_fields},
-            {"value": "Porifera", "child_count": 0, "descendant_count": 0, **common_fields},
+            {"value": "Arthropoda", "child_count": 0, **common_fields},
+            {"value": "Chordata", "child_count": 1, **common_fields},
+            {"value": "Cnidaria", "child_count": 0, **common_fields},
+            {"value": "Ctenophora", "child_count": 0, **common_fields},
+            {"value": "Gastrotrich", "child_count": 0, **common_fields},
+            {"value": "Placozoa", "child_count": 0, **common_fields},
+            {"value": "Porifera", "child_count": 0, **common_fields},
         ]
 
     def test_get_depth_1_search_term(self) -> None:
@@ -381,7 +381,6 @@ def test_get_depth_1_search_term(self) -> None:
             {
                 "value": "Archaea",
                 "child_count": 3,
-                "descendant_count": 3,
                 "depth": 0,
                 "usage_count": 0,
                 "parent_value": None,
@@ -400,7 +399,6 @@ def test_get_depth_1_child_search_term(self) -> None:
             {
                 "value": "Archaebacteria",
                 "child_count": 0,
-                "descendant_count": 0,
                 "depth": 1,
                 "parent_value": "Bacteria",
                 "external_id": None,
@@ -511,7 +509,6 @@ def test_tags_deep(self) -> None:
                 "depth": 3,
                 "usage_count": 0,
                 "child_count": 0,
-                "descendant_count": 0,
                 "external_id": None,
                 "_id": 21,  # These IDs are hard-coded in the test fixture file
             }

tests/openedx_tagging/test_views.py

@@ -1614,7 +1614,7 @@ def test_large_taxonomy(self):
         self.client.force_authenticate(user=self.staff)
 
         url = self.large_taxonomy_url + "?include_counts"
-        with self.assertNumQueries(1):
+        with self.assertNumQueries(3):
             response = self.client.get(url)
 
         assert response.status_code == status.HTTP_200_OK