openedx-learning 0.29.1__py2.py3-none-any.whl → 0.30.0__py2.py3-none-any.whl

openedx_learning/apps/authoring/publishing/migrations/0009_dependencies_and_hashing.py

@@ -0,0 +1,62 @@
+# Generated by Django 5.2.7 on 2025-10-29 17:59
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('oel_publishing', '0008_alter_draftchangelogrecord_options_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='draft',
+            name='draft_log_record',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, to='oel_publishing.draftchangelogrecord'),
+        ),
+        migrations.AddField(
+            model_name='draftchangelogrecord',
+            name='dependencies_hash_digest',
+            field=models.CharField(blank=True, default='', editable=False, max_length=8),
+        ),
+        migrations.AddField(
+            model_name='publishlogrecord',
+            name='dependencies_hash_digest',
+            field=models.CharField(blank=True, default='', editable=False, max_length=8),
+        ),
+        migrations.CreateModel(
+            name='PublishableEntityVersionDependency',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('referenced_entity', models.ForeignKey(on_delete=django.db.models.deletion.RESTRICT, to='oel_publishing.publishableentity')),
+                ('referring_version', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='oel_publishing.publishableentityversion')),
+            ],
+        ),
+        migrations.AddField(
+            model_name='publishableentityversion',
+            name='dependencies',
+            field=models.ManyToManyField(related_name='affects', through='oel_publishing.PublishableEntityVersionDependency', to='oel_publishing.publishableentity'),
+        ),
+        migrations.CreateModel(
+            name='PublishSideEffect',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('cause', models.ForeignKey(on_delete=django.db.models.deletion.RESTRICT, related_name='causes', to='oel_publishing.publishlogrecord')),
+                ('effect', models.ForeignKey(on_delete=django.db.models.deletion.RESTRICT, related_name='affected_by', to='oel_publishing.publishlogrecord')),
+            ],
+            options={
+                'verbose_name': 'Publish Side Effect',
+                'verbose_name_plural': 'Publish Side Effects',
+            },
+        ),
+        migrations.AddConstraint(
+            model_name='publishableentityversiondependency',
+            constraint=models.UniqueConstraint(fields=('referring_version', 'referenced_entity'), name='oel_pevd_uniq_rv_re'),
+        ),
+        migrations.AddConstraint(
+            model_name='publishsideeffect',
+            constraint=models.UniqueConstraint(fields=('cause', 'effect'), name='oel_pub_pse_uniq_c_e'),
+        ),
+    ]

openedx_learning/apps/authoring/publishing/migrations/0010_backfill_dependencies.py

@@ -0,0 +1,149 @@
+"""
+Backfill PublishableEntityVersionDependency entries based on ContainerVersions.
+
+We're introducing a lower-level publishing concept of a dependency that will be
+used by Containers, but this means we have to backfill that dependency info for
+existing Containers in the system.
+"""
+from django.db import migrations
+from django.db.models import F
+
+
+def create_backfill(apps, schema_editor):
+    """
+    Create dependency entries and update dep hashes for Draft and Published.
+    """
+    _create_dependencies(apps)
+    _update_drafts(apps)
+    _update_draft_dependencies_hashes(apps)
+    _update_published_dependencies_hashes(apps)
+
+
+def _create_dependencies(apps):
+    """
+    Populate the PublishableEntityVersion.dependencies relation.
+
+    The only ones we should have in the system at this point are the ones from
+    containers, so we query ContainerVersion for that.
+    """
+    PublishableEntityVersionDependency = apps.get_model(
+        "oel_publishing", "PublishableEntityVersionDependency"
+    )
+    ContainerVersion = apps.get_model("oel_publishing", "ContainerVersion")
+
+    for container_version in ContainerVersion.objects.all():
+        # child_entity_ids is a set to de-dupe. This doesn't handle pinned
+        # child references yet, but you can't actually make those in a real
+        # library yet, so we shouldn't have that data lying around to migrate.
+        child_entity_ids = set(
+            container_version
+                .entity_list
+                .entitylistrow_set
+                .all()
+                .values_list("entity_id", flat=True)
+        )
+        PublishableEntityVersionDependency.objects.bulk_create(
+            [
+                PublishableEntityVersionDependency(
+                    referring_version_id=container_version.pk,
+                    referenced_entity_id=entity_id
+                )
+                for entity_id in child_entity_ids
+            ],
+            ignore_conflicts=True,
+        )
+
+
+def _update_drafts(apps):
+    """
+    Update Draft entries to point to their most recent DraftLogRecord.
+
+    This is slow and expensive.
+    """
+    Draft = apps.get_model("oel_publishing", "Draft")
+    DraftChangeLogRecord = apps.get_model("oel_publishing", "DraftChangeLogRecord")
+    for draft in Draft.objects.all():
+        draft_log_record = (
+            # Find the most recent DraftChangeLogRecord related to this Draft,
+            DraftChangeLogRecord.objects
+                .filter(entity_id=draft.pk)
+                .order_by('-pk')
+                .first()
+        )
+        draft.draft_log_record = draft_log_record
+        draft.save()
+
+
+def _update_draft_dependencies_hashes(apps):
+    """
+    Update the dependency_hash_digest for all DraftChangeLogRecords.
+
+    Backfill dependency state hashes. The important thing here is that things
+    without dependencies will have the default (blank) state hash, so we only
+    need to query for Draft entries for Containers.
+
+    We are only backfilling the current DraftChangeLogRecords pointed to by the
+    Draft entries now. We are not backfilling all historical
+    DraftChangeLogRecords. Full historical reconstruction is probably possible,
+    but it's not really worth the cost and complexity.
+    """
+    from ..api import update_dependencies_hash_digests_for_log
+    from ..models import DraftChangeLog
+
+    # All DraftChangeLogs that have records that are pointed to by the current
+    # Draft and have a possibility of having dependencies.
+    change_logs = DraftChangeLog.objects.filter(
+        pk=F('records__entity__draft__draft_log_record__draft_change_log'),
+        records__entity__draft__version__isnull=False,
+        records__entity__container__isnull=False,
+    ).distinct()
+    for change_log in change_logs:
+        update_dependencies_hash_digests_for_log(change_log, backfill=True)
+
+def _update_published_dependencies_hashes(apps):
+    """
+    Update all container Published.dependencies_hash_digest
+
+    Backfill dependency state hashes. The important thing here is that things
+    without dependencies will have the default (blank) state hash, so we only
+    need to query for Published entries for Containers.
+    """
+    from ..api import update_dependencies_hash_digests_for_log
+    from ..models import PublishLog
+
+    # All PublishLogs that have records that are pointed to by the current
+    # Published and have a possibility of having dependencies.
+    change_logs = PublishLog.objects.filter(
+        pk=F('records__entity__published__publish_log_record__publish_log'),
+        records__entity__published__version__isnull=False,
+        records__entity__container__isnull=False,
+    ).distinct()
+    for change_log in change_logs:
+        update_dependencies_hash_digests_for_log(change_log, backfill=True)
+
+def remove_backfill(apps, schema_editor):
+    """
+    Reset all dep hash values to default ('') and remove dependencies.
+    """
+    Draft = apps.get_model("oel_publishing", "Draft")
+    DraftChangeLogRecord = apps.get_model("oel_publishing", "DraftChangeLogRecord")
+    PublishLogRecord = apps.get_model("oel_publishing", "PublishLogRecord")
+    PublishableEntityVersionDependency = apps.get_model(
+        "oel_publishing", "PublishableEntityVersionDependency"
+    )
+
+    PublishLogRecord.objects.all().update(dependencies_hash_digest='')
+    DraftChangeLogRecord.objects.all().update(dependencies_hash_digest='')
+    PublishableEntityVersionDependency.objects.all().delete()
+    Draft.objects.all().update(draft_log_record=None)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('oel_publishing', '0009_dependencies_and_hashing'),
+    ]
+
+    operations = [
+        migrations.RunPython(create_backfill, reverse_code=remove_backfill)
+    ]

openedx_learning/apps/authoring/publishing/models/__init__.py

@@ -17,11 +17,12 @@ from .container import Container, ContainerVersion
 from .draft_log import Draft, DraftChangeLog, DraftChangeLogRecord, DraftSideEffect
 from .entity_list import EntityList, EntityListRow
 from .learning_package import LearningPackage
-from .publish_log import Published, PublishLog, PublishLogRecord
+from .publish_log import Published, PublishLog, PublishLogRecord, PublishSideEffect
 from .publishable_entity import (
     PublishableContentModelRegistry,
     PublishableEntity,
     PublishableEntityMixin,
     PublishableEntityVersion,
+    PublishableEntityVersionDependency,
     PublishableEntityVersionMixin,
 )

openedx_learning/apps/authoring/publishing/models/draft_log.py

@@ -3,9 +3,10 @@ Models relating to the creation and management of Draft information.
 """
 from django.conf import settings
 from django.db import models
+from django.db.models import F, Q
 from django.utils.translation import gettext_lazy as _
 
-from openedx_learning.lib.fields import immutable_uuid_field, manual_date_time_field
+from openedx_learning.lib.fields import hash_field, immutable_uuid_field, manual_date_time_field
 
 from .learning_package import LearningPackage
 from .publishable_entity import PublishableEntity, PublishableEntityVersion
@@ -55,6 +56,60 @@ class Draft(models.Model):
         null=True,
         blank=True,
     )
+    # Note: this is actually a 1:1 relation in practice, but I'm keeping the
+    # definition more consistent with the Published model, which has an fkey
+    # to PublishLogRecord. Unlike PublishLogRecord, this fkey is a late
+    # addition to this data model, so we have to allow null values for the
+    # initial migration. But making this nullable also has another advantage,
+    # in that it allows us to set the draft_log_record to the most recent change
+    # while inside a bulk_draft_changes_for operation, and then delete that log
+    # record if it is undone in the same bulk operation.
+    draft_log_record = models.ForeignKey(
+        "DraftChangeLogRecord",
+        on_delete=models.SET_NULL,
+        null=True,
+    )
+
+    @property
+    def log_record(self):
+        return self.draft_log_record
+
+    class DraftQuerySet(models.QuerySet):
+        """
+        Custom QuerySet/Manager so we can chain common queries.
+        """
+
+        def with_unpublished_changes(self):
+            """
+            Drafts with versions that are different from what is Published.
+
+            This will not return Drafts that have unpublished changes in their
+            dependencies. Example: A Unit is published with a Component as one
+            of its child. Then someone modifies the draft of the Component. If
+            both the Unit and the Component Drafts were part of the queryset,
+            this method would return only the changed Component, and not the
+            Unit. (We can add this as an optional flag later if we want.)
+            """
+            return (
+                self.select_related("entity__published__version")
+
+                # Exclude where draft and published versions are the same
+                    .exclude(entity__published__version_id=F("version_id"))
+
+                # Account for soft-deletes:
+                # NULL != NULL in SQL, so simply excluding entities where
+                # the Draft and Published versions match will not catch the
+                # case where a soft-delete has been published (i.e. both the
+                # Draft and Published versions are NULL). We need to
+                # explicitly check for that case instead, or else we will
+                # re-publish the same soft-deletes over and over again.
+                    .exclude(
+                        Q(version__isnull=True) &
+                        Q(entity__published__version__isnull=True)
+                    )
+            )
+
+    objects = DraftQuerySet.as_manager()
 
 
 class DraftChangeLog(models.Model):
@@ -202,6 +257,22 @@ class DraftChangeLogRecord(models.Model):
         PublishableEntityVersion, on_delete=models.RESTRICT, null=True, blank=True
     )
 
+    # The dependencies_hash_digest is used when the version alone isn't enough
+    # to let us know the full draft state of an entity. This happens any time a
+    # Draft version has dependencies (see the PublishableEntityVersionDependency
+    # model), because changes in those dependencies will cause changes to the
+    # state of the Draft. The main example of this is containers, where changing
+    # an unpinned child affects the state of the parent container, even if that
+    # container's definition (and thus version) does not change.
+    #
+    # If a Draft has no dependencies, then its entire state is captured by its
+    # version, and the dependencies_hash_digest is blank. (Blank is slightly
+    # more convenient for database comparisons than NULL.)
+    #
+    # Note: There is an equivalent of this field in the Published model and the
+    # the values may drift away from each other.
+    dependencies_hash_digest = hash_field(blank=True, default='', max_length=8)
+
     class Meta:
         constraints = [
             # A PublishableEntity can have only one DraftLogRecord per DraftLog.
@@ -228,6 +299,11 @@ class DraftChangeLogRecord(models.Model):
         verbose_name = _("Draft Change Log Record")
         verbose_name_plural = _("Draft Change Log Records")
 
+    def __str__(self):
+        old_version_num = None if self.old_version is None else self.old_version.version_num
+        new_version_num = None if self.new_version is None else self.new_version.version_num
+        return f"DraftChangeLogRecord: {self.entity} ({old_version_num} -> {new_version_num})"
+
 
 class DraftSideEffect(models.Model):
     """

openedx_learning/apps/authoring/publishing/models/entity_list.py

@@ -1,6 +1,8 @@
 """
 Entity List models
 """
+from functools import cached_property
+
 from django.db import models
 
 from .publishable_entity import PublishableEntity, PublishableEntityVersion
@@ -16,6 +18,17 @@ class EntityList(models.Model):
     anonymous in a sense–they're pointed to by ContainerVersions and
     other models, rather than being looked up by their own identifiers.
     """
+    @cached_property
+    def rows(self):
+        """
+        Convenience method to iterate rows.
+
+        I'd normally make this the reverse lookup name for the EntityListRow ->
+        EntityList foreign key relation, but we already have references to
+        entitylistrow_set in various places, and I thought this would be better
+        than breaking compatibility.
+        """
+        return self.entitylistrow_set.order_by("order_num")
 
 
 class EntityListRow(models.Model):
@@ -59,6 +72,12 @@ class EntityListRow(models.Model):
         related_name="+",  # Do we need the reverse relation?
     )
 
+    def is_pinned(self):
+        return self.entity_version_id is not None
+
+    def is_unpinned(self):
+        return self.entity_version_id is None
+
     class Meta:
         ordering = ["order_num"]
         constraints = [

openedx_learning/apps/authoring/publishing/models/publish_log.py

@@ -3,8 +3,14 @@ PublishLog and PublishLogRecord models
 """
 from django.conf import settings
 from django.db import models
+from django.utils.translation import gettext_lazy as _
 
-from openedx_learning.lib.fields import case_insensitive_char_field, immutable_uuid_field, manual_date_time_field
+from openedx_learning.lib.fields import (
+    case_insensitive_char_field,
+    hash_field,
+    immutable_uuid_field,
+    manual_date_time_field,
+)
 
 from .learning_package import LearningPackage
 from .publishable_entity import PublishableEntity, PublishableEntityVersion
@@ -61,6 +67,14 @@ class PublishLogRecord(models.Model):
 
     To revert a publish, we would make a new publish that swaps ``old_version``
     and ``new_version`` field values.
+
+    If the old_version and new_version of a PublishLogRecord match, it means
+    that the definition of the entity itself did not change (i.e. no new
+    PublishableEntityVersion was created), but something else was published that
+    had the side-effect of changing the published state of this entity. For
+    instance, if a Unit has unpinned references to its child Components (which
+    it almost always will), then publishing one of those Components will alter
+    the published state of the Unit, even if the UnitVersion does not change.
     """
 
     publish_log = models.ForeignKey(
@@ -80,6 +94,23 @@ class PublishLogRecord(models.Model):
         PublishableEntityVersion, on_delete=models.RESTRICT, null=True, blank=True
     )
 
+    # The dependencies_hash_digest is used when the version alone isn't enough
+    # to let us know the full draft state of an entity. This happens any time a
+    # Published version has dependencies (see the
+    # PublishableEntityVersionDependency model), because changes in those
+    # dependencies will cause changes to the state of the Draft. The main
+    # example of this is containers, where changing an unpinned child affects
+    # the state of the parent container, even if that container's definition
+    # (and thus version) does not change.
+    #
+    # If a Published version has no dependencies, then its entire state is
+    # captured by its version, and the dependencies_hash_digest is blank. (Blank
+    # is slightly more convenient for database comparisons than NULL.)
+    #
+    # Note: There is an equivalent of this field in the Draft model and the
+    # the values may drift away from each other.
+    dependencies_hash_digest = hash_field(blank=True, default='', max_length=8)
+
     class Meta:
         constraints = [
             # A Publishable can have only one PublishLogRecord per PublishLog.
@@ -105,6 +136,11 @@ class PublishLogRecord(models.Model):
         verbose_name = "Publish Log Record"
         verbose_name_plural = "Publish Log Records"
 
+    def __str__(self):
+        old_version_num = None if self.old_version is None else self.old_version.version_num
+        new_version_num = None if self.new_version is None else self.new_version.version_num
+        return f"PublishLogRecord: {self.entity} ({old_version_num} -> {new_version_num})"
+
 
 class Published(models.Model):
     """
@@ -145,6 +181,56 @@ class Published(models.Model):
         on_delete=models.RESTRICT,
     )
 
+    @property
+    def log_record(self):
+        return self.publish_log_record
+
     class Meta:
         verbose_name = "Published Entity"
         verbose_name_plural = "Published Entities"
+
+
+class PublishSideEffect(models.Model):
+    """
+    Model to track when a change in one Published entity affects others.
+
+    Our first use case for this is that changes involving child components are
+    thought to affect parent Units, even if the parent's version doesn't change.
+
+    Side-effects are recorded in a collapsed form that only captures one level.
+    So if Components C1 and C2 are both published and they are part of Unit U1,
+    which is in turn a part of Subsection SS1, then the PublishSideEffect
+    entries are::
+
+      (C1, U1)
+      (C2, U1)
+      (U1, SS1)
+
+    We do not keep entries for (C1, SS1) or (C2, SS1). This is to make the model
+    simpler, so we don't have to differentiate between direct side-effects and
+    transitive side-effects in the model.
+
+    .. no_pii:
+    """
+    cause = models.ForeignKey(
+        PublishLogRecord,
+        on_delete=models.RESTRICT,
+        related_name='causes',
+    )
+    effect = models.ForeignKey(
+        PublishLogRecord,
+        on_delete=models.RESTRICT,
+        related_name='affected_by',
+    )
+
+    class Meta:
+        constraints = [
+            # Duplicate entries for cause & effect are just redundant. This is
+            # here to guard against weird bugs that might introduce this state.
+            models.UniqueConstraint(
+                fields=["cause", "effect"],
+                name="oel_pub_pse_uniq_c_e",
+            )
+        ]
+        verbose_name = _("Publish Side Effect")
+        verbose_name_plural = _("Publish Side Effects")

openedx_learning/apps/authoring/publishing/models/publishable_entity.py

@@ -1,6 +1,8 @@
 """
 PublishableEntity model and PublishableEntityVersion + mixins
 """
+from __future__ import annotations
+
 from datetime import datetime
 from functools import cached_property
 from typing import ClassVar, Self
@@ -185,6 +187,8 @@ class PublishableEntityVersion(models.Model):
     connect them using a OneToOneField with primary_key=True. The easiest way to
     do this is to inherit from PublishableEntityVersionMixin. Be sure to treat
     these versioned models in your app as immutable as well.
+
+    .. no_pii
     """
 
     uuid = immutable_uuid_field()
@@ -221,6 +225,14 @@ class PublishableEntityVersion(models.Model):
         blank=True,
     )
 
+    dependencies: models.ManyToManyField[
+        PublishableEntity, PublishableEntityVersionDependency
+    ] = models.ManyToManyField(
+        PublishableEntity,
+        through="PublishableEntityVersionDependency",
+        related_name="affects",
+    )
+
     def __str__(self):
         return f"{self.entity.key} @ v{self.version_num} - {self.title}"
 
@@ -265,6 +277,42 @@ class PublishableEntityVersion(models.Model):
         verbose_name_plural = "Publishable Entity Versions"
 
 
+class PublishableEntityVersionDependency(models.Model):
+    """
+    Track the PublishableEntities that a PublishableEntityVersion depends on.
+
+    For example, a partcular version of a Unit (U1.v1) might be defined to have
+    unpinned references to Components C1 and C2. That means that any changes in
+    C1 or C2 will affect U1.v1 via DraftSideEffects and PublishedSideEffects. We
+    say that C1 and C2 are dependencies of U1.v1.
+
+    An important restriction is that a PublishableEntityVersion's list of
+    dependencies are defined when the version is created. It is not modified
+    after that. No matter what happens to C1 or C2 (e.g. edit, deletion,
+    un-deletion, reset-draft-version-to-published), they will always be
+    dependencies of U1.v1.
+
+    If someone removes C2 from U1, then that requires creating a new version of
+    U1 (so U1.v2).
+
+    This restriction is important because our ability to calculate and cache the
+    state of "this version of this publishable entity and all its dependencies
+    (children)" relies on this being true.
+
+    .. no_pii
+    """
+    referring_version = models.ForeignKey(PublishableEntityVersion, on_delete=models.CASCADE)
+    referenced_entity = models.ForeignKey(PublishableEntity, on_delete=models.RESTRICT)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["referring_version", "referenced_entity"],
+                name="oel_pevd_uniq_rv_re",
+            )
+        ]
+
+
 class PublishableEntityMixin(models.Model):
     """
     Convenience mixin to link your models against PublishableEntity.

openedx_learning/apps/authoring/units/api.py

@@ -194,7 +194,7 @@ def create_unit_and_version(
         can_stand_alone: Set to False when created as part of containers
     """
     entity_rows = _pub_entities_for_components(components)
-    with atomic():
+    with atomic(savepoint=False):
         unit = create_unit(
             learning_package_id,
             key,

openedx_learning/lib/fields.py

@@ -19,11 +19,12 @@ from .collations import MultiCollationMixin
 from .validators import validate_utc_datetime
 
 
-def create_hash_digest(data_bytes: bytes) -> str:
+def create_hash_digest(data_bytes: bytes, num_bytes=20) -> str:
     """
-    Create a 40-byte, lower-case hex string representation of a hash digest.
+    Create a lower-case hex string representation of a hash digest.
 
-    The hash digest itself is 20-bytes using BLAKE2b.
+    The hash itself is 20-bytes by default, so 40 characters when we return it
+    as a hex-encoded string. We use BLAKE2b for the hashing algorithm.
 
     DON'T JUST MODIFY THIS HASH BEHAVIOR!!! We use hashing for de-duplication
     purposes. If this hash function ever changes, that deduplication will fail
@@ -32,7 +33,7 @@ def create_hash_digest(data_bytes: bytes) -> str:
     If we want to change this representation one day, we should create a new
     function for that and do the appropriate data migration.
     """
-    return hashlib.blake2b(data_bytes, digest_size=20).hexdigest()
+    return hashlib.blake2b(data_bytes, digest_size=num_bytes).hexdigest()
 
 
 def case_insensitive_char_field(**kwargs) -> MultiCollationCharField:
@@ -123,7 +124,7 @@ def key_field(**kwargs) -> MultiCollationCharField:
     return case_sensitive_char_field(max_length=500, blank=False, **kwargs)
 
 
-def hash_field() -> models.CharField:
+def hash_field(**kwargs) -> models.CharField:
     """
     Holds a hash digest meant to identify a piece of content.
 
@@ -144,12 +145,13 @@ def hash_field() -> models.CharField:
        didn't seem worthwhile, particularly the possibility of case-sensitivity
        related bugs.
     """
-    return models.CharField(
-        max_length=40,
-        blank=False,
-        null=False,
-        editable=False,
-    )
+    default_kwargs = {
+        "max_length": 40,
+        "blank": False,
+        "null": False,
+        "editable": False,
+    }
+    return models.CharField(**(default_kwargs | kwargs))
 
 
 def manual_date_time_field() -> models.DateTimeField:

{openedx_learning-0.29.1.dist-info → openedx_learning-0.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openedx-learning
-Version: 0.29.1
+Version: 0.30.0
 Summary: Open edX Learning Core and Tagging.
 Home-page: https://github.com/openedx/openedx-learning
 Author: David Ormsbee
@@ -19,13 +19,13 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.11
 License-File: LICENSE.txt
-Requires-Dist: rules<4.0
-Requires-Dist: edx-drf-extensions
-Requires-Dist: Django
 Requires-Dist: tomlkit
-Requires-Dist: djangorestframework<4.0
-Requires-Dist: attrs
+Requires-Dist: Django
+Requires-Dist: edx-drf-extensions
 Requires-Dist: celery
+Requires-Dist: attrs
+Requires-Dist: djangorestframework<4.0
+Requires-Dist: rules<4.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier