refactor: adjust indentation

openedx_learning/core/components/api.py

@@ -76,7 +76,7 @@ def create_component_version(
 def create_next_version(
     component_pk: int,
     title: str,
-    content_to_replace: dict[str: int],
+    content_to_replace: dict[str: int | None],
     created: datetime,
     created_by: int | None = None,
 ) -> ComponentVersion:
@@ -118,17 +118,23 @@ def create_next_version(
         )
         # First copy the new stuff over...
         for key, raw_content_pk in content_to_replace.items():
-            ComponentVersionRawContent.objects.create(
-                raw_content_id=raw_content_pk,
-                component_version=component_version,
-                key=key,
-                learner_downloadable=False,
-            )
+            # If the raw_content_pk is None, it means we want to remove the
+            # content represented by our key from the next version. Otherwise,
+            # we add our key->raw_content_pk mapping to the next version.
+            if raw_content_pk is not None:
+                ComponentVersionRawContent.objects.create(
+                    raw_content_id=raw_content_pk,
+                    component_version=component_version,
+                    key=key,
+                    learner_downloadable=False,
+                )
         # Now copy any old associations that existed, as long as they don't
         # conflict with the new stuff.
-        last_version_content_mapping = ComponentVersionRawContent.objects \
-                                           .filter(component_version=last_version) \
-                                           .all()
+        last_version_content_mapping = (
+            ComponentVersionRawContent
+                .objects
+                .filter(component_version=last_version)
+        )
         for cvrc in last_version_content_mapping:
             if cvrc.key not in content_to_replace:
                 ComponentVersionRawContent.objects.create(
@@ -229,9 +235,12 @@ def get_components(
     info from the Component's draft and published versions, since we'll be
     referencing these a lot.
     """
-    qset = Component.with_publishing_relations \
-                    .filter(learning_package_id=learning_package_id) \
-                    .order_by('pk')
+    qset = (
+        Component
+            .with_publishing_relations
+            .filter(learning_package_id=learning_package_id)
+            .order_by('pk')
+    )
     if draft is not None:
         qset = qset.filter(publishable_entity__draft__version__isnull = not draft)
     if published is not None:
@@ -257,21 +266,25 @@ def get_component_version_content(
     Can raise a django.core.exceptions.ObjectDoesNotExist error if there is no
     matching ComponentVersionRawContent.
     """
-    return ComponentVersionRawContent.objects.select_related(
-        "raw_content",
-        "raw_content__media_type",
-        "raw_content__textcontent",
-        "component_version",
-        "component_version__component",
-        "component_version__component__learning_package",
-    ).get(
-        Q(component_version__component__learning_package__key=learning_package_key)
-        & Q(component_version__component__publishable_entity__key=component_key)
-        & Q(component_version__publishable_entity_version__version_num=version_num)
-        & Q(key=key)
+    return (
+        ComponentVersionRawContent
+            .objects
+            .select_related(
+                "raw_content",
+                "raw_content__media_type",
+                "raw_content__textcontent",
+                "component_version",
+                "component_version__component",
+                "component_version__component__learning_package",
+            )
+            .get(
+                Q(component_version__component__learning_package__key=learning_package_key)
+                & Q(component_version__component__publishable_entity__key=component_key)
+                & Q(component_version__publishable_entity_version__version_num=version_num)
+                & Q(key=key)
+            )
     )
 
-
 def add_content_to_component_version(
     component_version_id: int,
     raw_content_id: int,

openedx_learning/core/publishing/api.py

@@ -163,10 +163,13 @@ def learning_package_exists(key: str) -> bool:
 
 
 def get_last_publish(learning_package_id: int) -> PublishLog | None:
-    return PublishLog.objects \
-                     .filter(learning_package_id=learning_package_id) \
-                     .order_by('-id') \
-                     .first()
+    return (
+        PublishLog
+            .objects
+            .filter(learning_package_id=learning_package_id)
+            .order_by('-id')
+            .first()
+    )
 
 def get_all_drafts(learning_package_id: int):
     return Draft.objects.filter(
@@ -175,23 +178,28 @@ def get_all_drafts(learning_package_id: int):
     )
 
 def get_entities_with_unpublished_changes(learning_package_id: int):
-    return PublishableEntity.objects \
-               .filter(learning_package_id=learning_package_id) \
-               .exclude(draft__version=F('published__version'))
+    return (
+        PublishableEntity
+            .objects
+            .filter(learning_package_id=learning_package_id)
+            .exclude(draft__version=F('published__version'))
+    )
 
 def get_entities_with_unpublished_deletes(learning_package_id: int):
     """
     Something will become "deleted" if it has a null Draft version but a
     not-null Published version. (If both are null, it means it's already been
     deleted in a previous publish, or it was never published.)
     """
-    return PublishableEntity.objects \
-               .filter(
-                   learning_package_id=learning_package_id,
-                   draft__version__isnull=True,
-                ) \
-               .exclude(published__version__isnull=True)
-
+    return (
+        PublishableEntity
+            .objects
+            .filter(
+                learning_package_id=learning_package_id,
+                draft__version__isnull=True,
+            )
+            .exclude(published__version__isnull=True)
+    )
 
 def publish_all_drafts(
     learning_package_id: int,
@@ -203,9 +211,11 @@ def publish_all_drafts(
     Publish everything that is a Draft and is not already published.
     """
     draft_qset = (
-        Draft.objects.select_related("entity__published")
-                     .filter(entity__learning_package_id=learning_package_id)
-                     .exclude(entity__published__version_id=F("version_id"))
+        Draft
+            .objects
+            .select_related("entity__published")
+            .filter(entity__learning_package_id=learning_package_id)
+            .exclude(entity__published__version_id=F("version_id"))
     )
     return publish_from_drafts(
         learning_package_id, draft_qset, message, published_at, published_by
@@ -317,16 +327,18 @@ def reset_drafts_to_published(learning_package_id: int) -> None:
     """
     # These are all the drafts that are different from the publisehd versions.
     draft_qset = (
-        Draft.objects.select_related("entity__published")
-        .filter(entity__learning_package_id=learning_package_id)
-        .exclude(entity__published__version_id=F("version_id"))
+        Draft
+            .objects
+            .select_related("entity__published")
+            .filter(entity__learning_package_id=learning_package_id)
+            .exclude(entity__published__version_id=F("version_id"))
     )
     # Note: We can't do an .update with a F() on a joined field in the ORM, so
     # we have to loop through the drafts individually to reset them. We can
     # rework this into a bulk update or custom SQL if it becomes a performance
     # issue.
     with atomic():
-        for draft in draft_qset.all():
+        for draft in draft_qset:
             if hasattr(draft.entity, 'published'):
                 draft.version_id = draft.entity.published.version_id
             else:

tests/openedx_learning/core/components/test_api.py

@@ -349,16 +349,18 @@ def test_add(self):
             learner_downloadable=False,
         )
         # re-fetch from the database to check to see if we wrote it correctly
-        new_version = components_api.get_component(self.problem.pk) \
-                                    .versions \
-                                    .get(publishable_entity_version__version_num=1)
+        new_version = (
+            components_api
+                .get_component(self.problem.pk)
+                .versions
+                .get(publishable_entity_version__version_num=1)
+        )
         assert (
             new_content ==
             new_version.raw_contents.get(componentversionrawcontent__key="hello.txt")
         )
 
 
-
     def test_multiple_versions(self):
         hello_content, _created = contents_api.get_or_create_text_content_from_bytes(
             learning_package_id=self.learning_package.id,
@@ -421,19 +423,22 @@ def test_multiple_versions(self):
         assert version_2.raw_contents.count() == 3
         assert (
             blank_content ==
-            version_2.raw_contents
-                     .get(componentversionrawcontent__key="hello.txt")
-                     .text_content
+            version_2
+                .raw_contents
+                .get(componentversionrawcontent__key="hello.txt")
+                .text_content
         )
         assert (
             goodbye_content ==
-            version_2.raw_contents
-                     .get(componentversionrawcontent__key="goodbye.txt")
-                     .text_content
+            version_2
+                .raw_contents
+                .get(componentversionrawcontent__key="goodbye.txt")
+                .text_content
         )
         assert (
             blank_content ==
-            version_2.raw_contents
-                     .get(componentversionrawcontent__key="blank.txt")
-                     .text_content
+            version_2
+                .raw_contents
+                .get(componentversionrawcontent__key="blank.txt")
+                .text_content
         )