openedx-learning 0.27.0__tar.gz → 0.28.0__tar.gz

{openedx_learning-0.27.0/openedx_learning.egg-info → openedx_learning-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openedx-learning
-Version: 0.27.0
+Version: 0.28.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: Django
-Requires-Dist: rules<4.0
 Requires-Dist: celery
-Requires-Dist: djangorestframework<4.0
-Requires-Dist: attrs
-Requires-Dist: tomlkit
+Requires-Dist: rules<4.0
+Requires-Dist: Django
 Requires-Dist: edx-drf-extensions
+Requires-Dist: tomlkit
+Requires-Dist: attrs
+Requires-Dist: djangorestframework<4.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/__init__.py

@@ -2,4 +2,4 @@
 Open edX Learning ("Learning Core").
 """
 
-__version__ = "0.27.0"
+__version__ = "0.28.0"

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/api/authoring.py

@@ -9,6 +9,7 @@ APIs.
 """
 # These wildcard imports are okay because these api modules declare __all__.
 # pylint: disable=wildcard-import
+from ..apps.authoring.backup_restore.api import *
 from ..apps.authoring.collections.api import *
 from ..apps.authoring.components.api import *
 from ..apps.authoring.contents.api import *

openedx_learning-0.28.0/openedx_learning/apps/authoring/backup_restore/api.py

@@ -0,0 +1,15 @@
+"""
+Backup Restore API
+"""
+from openedx_learning.apps.authoring.backup_restore.zipper import LearningPackageZipper
+from openedx_learning.apps.authoring.publishing.api import get_learning_package_by_key
+
+
+def create_zip_file(lp_key: str, path: str) -> None:
+    """
+    Creates a zip file with a toml file so far (WIP)
+
+    Can throw a NotFoundError at get_learning_package_by_key
+    """
+    learning_package = get_learning_package_by_key(lp_key)
+    LearningPackageZipper(learning_package).create_zip(path)

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/backup_restore/management/commands/lp_dump.py

@@ -33,7 +33,6 @@ class Command(BaseCommand):
             self.stdout.write(self.style.SUCCESS(message))
         except LearningPackage.DoesNotExist as exc:
             message = f"Learning package with key {lp_key} not found"
-            logger.exception(message)
             raise CommandError(message) from exc
         except Exception as e:
             message = f"Failed to export learning package '{lp_key}': {e}"

openedx_learning-0.28.0/openedx_learning/apps/authoring/backup_restore/toml.py

@@ -0,0 +1,76 @@
+"""
+TOML serialization for learning packages and publishable entities.
+"""
+
+from datetime import datetime
+
+import tomlkit
+
+from openedx_learning.apps.authoring.publishing import api as publishing_api
+from openedx_learning.apps.authoring.publishing.models import PublishableEntity, PublishableEntityVersion
+from openedx_learning.apps.authoring.publishing.models.learning_package import LearningPackage
+
+
+def toml_learning_package(learning_package: LearningPackage) -> str:
+    """Create a TOML representation of the learning package."""
+    doc = tomlkit.document()
+    doc.add(tomlkit.comment(f"Datetime of the export: {datetime.now()}"))
+    section = tomlkit.table()
+    section.add("title", learning_package.title)
+    section.add("key", learning_package.key)
+    section.add("description", learning_package.description)
+    section.add("created", learning_package.created)
+    section.add("updated", learning_package.updated)
+    doc.add("learning_package", section)
+    return tomlkit.dumps(doc)
+
+
+def toml_publishable_entity(entity: PublishableEntity) -> str:
+    """Create a TOML representation of a publishable entity."""
+
+    current_draft_version = publishing_api.get_draft_version(entity)
+    current_published_version = publishing_api.get_published_version(entity)
+
+    doc = tomlkit.document()
+    entity_table = tomlkit.table()
+    entity_table.add("uuid", str(entity.uuid))
+    entity_table.add("can_stand_alone", entity.can_stand_alone)
+
+    if current_draft_version:
+        draft_table = tomlkit.table()
+        draft_table.add("version_num", current_draft_version.version_num)
+        entity_table.add("draft", draft_table)
+
+    published_table = tomlkit.table()
+    if current_published_version:
+        published_table.add("version_num", current_published_version.version_num)
+    else:
+        published_table.add(tomlkit.comment("unpublished: no published_version_num"))
+    entity_table.add("published", published_table)
+
+    doc.add("entity", entity_table)
+    doc.add(tomlkit.nl())
+    doc.add(tomlkit.comment("### Versions"))
+
+    for entity_version in entity.versions.all():
+        version = tomlkit.aot()
+        version_table = toml_publishable_entity_version(entity_version)
+        version.append(version_table)
+        doc.add("version", version)
+
+    return tomlkit.dumps(doc)
+
+
+def toml_publishable_entity_version(version: PublishableEntityVersion) -> tomlkit.items.Table:
+    """Create a TOML representation of a publishable entity version."""
+    version_table = tomlkit.table()
+    version_table.add("title", version.title)
+    version_table.add("uuid", str(version.uuid))
+    version_table.add("version_num", version.version_num)
+    container_table = tomlkit.table()
+    container_table.add("children", [])
+    unit_table = tomlkit.table()
+    unit_table.add("graded", True)
+    container_table.add("unit", unit_table)
+    version_table.add("container", container_table)
+    return version_table  # For use in AoT

openedx_learning-0.28.0/openedx_learning/apps/authoring/backup_restore/zipper.py

@@ -0,0 +1,242 @@
+"""
+This module provides functionality to create a zip file containing the learning package data,
+including a TOML representation of the learning package and its entities.
+"""
+import hashlib
+import zipfile
+from pathlib import Path
+from typing import List, Optional
+
+from django.db.models import Prefetch, QuerySet
+from django.utils.text import slugify
+
+from openedx_learning.api.authoring_models import (
+    ComponentVersion,
+    ComponentVersionContent,
+    Content,
+    LearningPackage,
+    PublishableEntity,
+    PublishableEntityVersion,
+)
+from openedx_learning.apps.authoring.backup_restore.toml import toml_learning_package, toml_publishable_entity
+from openedx_learning.apps.authoring.publishing import api as publishing_api
+
+TOML_PACKAGE_NAME = "package.toml"
+
+
+def slugify_hashed_filename(identifier: str) -> str:
+    """
+    Generate a filesystem-safe filename from an identifier.
+
+    Why:
+        Identifiers may contain characters that are invalid or ambiguous
+        in filesystems (e.g., slashes, colons, case differences).
+        Additionally, two different identifiers might normalize to the same
+        slug after cleaning. To avoid collisions and ensure uniqueness,
+        we append a short blake2b hash.
+
+    What:
+        - Slugify the identifier (preserves most characters, only strips
+          filesystem-invalid ones).
+        - Append a short hash for uniqueness.
+        - Result: human-readable but still unique and filesystem-safe filename.
+    """
+    slug = slugify(identifier, allow_unicode=True)
+    # Short digest ensures uniqueness without overly long filenames
+    short_hash = hashlib.blake2b(
+        identifier.encode("utf-8"),
+        digest_size=3,
+    ).hexdigest()
+    return f"{slug}_{short_hash}"
+
+
+class LearningPackageZipper:
+    """
+    A class to handle the zipping of learning content for backup and restore.
+    """
+
+    def __init__(self, learning_package: LearningPackage):
+        self.learning_package = learning_package
+        self.folders_already_created: set[Path] = set()
+
+    def create_folder(self, folder_path: Path, zip_file: zipfile.ZipFile) -> None:
+        """
+        Create a folder for the zip file structure.
+        Skips creating the folder if it already exists based on the folder path.
+        Args:
+            folder_path (Path): The path of the folder to create.
+        """
+        if folder_path not in self.folders_already_created:
+            zip_info = zipfile.ZipInfo(str(folder_path) + "/")
+            zip_file.writestr(zip_info, "")  # Add explicit empty directory entry
+            self.folders_already_created.add(folder_path)
+
+    def get_publishable_entities(self) -> QuerySet[PublishableEntity]:
+        """
+        Retrieve the publishable entities associated with the learning package.
+        Prefetches related data for efficiency.
+        """
+        lp_id = self.learning_package.pk
+        publishable_entities: QuerySet[PublishableEntity] = publishing_api.get_publishable_entities(lp_id)
+        return (
+            publishable_entities
+            .select_related(
+                "container",
+                "component__component_type",
+                "draft__version__componentversion",
+                "published__version__componentversion",
+            )
+            .prefetch_related(
+                # We should re-evaluate the prefetching strategy here,
+                # as the current approach may cause performance issues—
+                # especially with large libraries (up to 100K items),
+                # which is too large for this type of prefetch.
+                Prefetch(
+                    "draft__version__componentversion__componentversioncontent_set",
+                    queryset=ComponentVersionContent.objects.select_related("content"),
+                    to_attr="prefetched_contents",
+                ),
+                Prefetch(
+                    "published__version__componentversion__componentversioncontent_set",
+                    queryset=ComponentVersionContent.objects.select_related("content"),
+                    to_attr="prefetched_contents",
+                ),
+            )
+        )
+
+    def get_versions_to_write(self, entity: PublishableEntity):
+        """
+        Get the versions of a publishable entity that should be written to the zip file.
+        It retrieves both draft and published versions.
+        """
+        draft_version: Optional[PublishableEntityVersion] = publishing_api.get_draft_version(entity)
+        published_version: Optional[PublishableEntityVersion] = publishing_api.get_published_version(entity)
+
+        versions_to_write = [draft_version] if draft_version else []
+
+        if published_version and published_version != draft_version:
+            versions_to_write.append(published_version)
+        return versions_to_write
+
+    def create_zip(self, path: str) -> None:
+        """
+        Creates a zip file containing the learning package data.
+        Args:
+            path (str): The path where the zip file will be created.
+        Raises:
+            Exception: If the learning package cannot be found or if the zip creation fails.
+        """
+
+        with zipfile.ZipFile(path, "w", compression=zipfile.ZIP_DEFLATED) as zipf:
+            # Add the package.toml file
+            package_toml_content: str = toml_learning_package(self.learning_package)
+            zipf.writestr(TOML_PACKAGE_NAME, package_toml_content)
+
+            # Add the entities directory
+            entities_folder = Path("entities")
+            self.create_folder(entities_folder, zipf)
+
+            # Add the collections directory
+            collections_folder = Path("collections")
+            self.create_folder(collections_folder, zipf)
+
+            # ------ ENTITIES SERIALIZATION -------------
+
+            # get the publishable entities
+            publishable_entities: QuerySet[PublishableEntity] = self.get_publishable_entities()
+
+            for entity in publishable_entities:
+                # entity: PublishableEntity = entity  # Type hint for clarity
+
+                # Create a TOML representation of the entity
+                entity_toml_content: str = toml_publishable_entity(entity)
+
+                if hasattr(entity, 'container'):
+                    entity_slugify_hash = slugify_hashed_filename(entity.key)
+                    entity_toml_filename = f"{entity_slugify_hash}.toml"
+                    entity_toml_path = entities_folder / entity_toml_filename
+                    zipf.writestr(str(entity_toml_path), entity_toml_content)
+
+                if hasattr(entity, 'component'):
+                    # Create the component folder structure for the entity. The structure is as follows:
+                    # entities/
+                    #     xblock.v1/  (component namespace)
+                    #         html/  (component type)
+                    #             my_component.toml  (entity TOML file)
+                    #             my_component/  (component id)
+                    #                 component_versions/
+                    #                     v1/
+                    #                         static/
+
+                    # Generate the slugified hash for the component local key
+                    # Example: if the local key is "my_component", the slugified hash might be "my_component_123456"
+                    # It's a combination of the local key and a hash and should be unique
+                    entity_slugify_hash = slugify_hashed_filename(entity.component.local_key)
+
+                    # Create the component namespace folder
+                    # Example of component namespace is: "entities/xblock.v1/"
+                    component_namespace_folder = entities_folder / entity.component.component_type.namespace
+                    self.create_folder(component_namespace_folder, zipf)
+
+                    # Create the component type folder
+                    # Example of component type is: "entities/xblock.v1/html/"
+                    component_type_folder = component_namespace_folder / entity.component.component_type.name
+                    self.create_folder(component_type_folder, zipf)
+
+                    # Create the component id folder
+                    # Example of component id is: "entities/xblock.v1/html/my_component_123456/"
+                    component_id_folder = component_type_folder / entity_slugify_hash
+                    self.create_folder(component_id_folder, zipf)
+
+                    # Add the entity TOML file inside the component type folder as well
+                    # Example: "entities/xblock.v1/html/my_component_123456.toml"
+                    component_entity_toml_path = component_type_folder / f"{entity_slugify_hash}.toml"
+                    zipf.writestr(str(component_entity_toml_path), entity_toml_content)
+
+                    # Add component version folder into the component id folder
+                    # Example: "entities/xblock.v1/html/my_component_123456/component_versions/"
+                    component_version_folder = component_id_folder / "component_versions"
+                    self.create_folder(component_version_folder, zipf)
+
+                    # ------ COMPONENT VERSIONING -------------
+                    # Focusing on draft and published versions
+
+                    # Get the draft and published versions
+                    versions_to_write: List[PublishableEntityVersion] = self.get_versions_to_write(entity)
+
+                    for version in versions_to_write:
+                        # Create a folder for the version
+                        version_number = f"v{version.version_num}"
+                        version_folder = component_version_folder / version_number
+                        self.create_folder(version_folder, zipf)
+
+                        # Add static folder for the version
+                        static_folder = version_folder / "static"
+                        self.create_folder(static_folder, zipf)
+
+                        # ------ COMPONENT STATIC CONTENT -------------
+                        component_version: ComponentVersion = version.componentversion
+
+                        # Get content data associated with this version
+                        contents: QuerySet[
+                            ComponentVersionContent
+                        ] = component_version.prefetched_contents  # type: ignore[attr-defined]
+
+                        for component_version_content in contents:
+                            content: Content = component_version_content.content
+
+                            # Important: The component_version_content.key contains implicitly
+                            # the file name and the file extension
+                            file_path = version_folder / component_version_content.key
+
+                            if content.has_file and content.path:
+                                # If has_file, we pull it from the file system
+                                with content.read_file() as f:
+                                    file_data = f.read()
+                            elif not content.has_file and content.text:
+                                # Otherwise, we use the text content as the file data
+                                file_data = content.text
+                            else:
+                                # If no file and no text, we skip this content
+                                continue
+                            zipf.writestr(str(file_path), file_data)

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/components/apps.py

@@ -18,7 +18,7 @@ class ComponentsConfig(AppConfig):
         """
         Register Component and ComponentVersion.
         """
-        from ..publishing.api import register_content_models  # pylint: disable=import-outside-toplevel
+        from ..publishing.api import register_publishable_models  # pylint: disable=import-outside-toplevel
         from .models import Component, ComponentVersion  # pylint: disable=import-outside-toplevel
 
-        register_content_models(Component, ComponentVersion)
+        register_publishable_models(Component, ComponentVersion)

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/publishing/api.py

@@ -10,7 +10,7 @@ from contextlib import nullcontext
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from enum import Enum
-from typing import ContextManager, TypeVar
+from typing import ContextManager, Optional, TypeVar
 
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db.models import F, Q, QuerySet
@@ -58,6 +58,7 @@ __all__ = [
     "create_publishable_entity_version",
     "get_publishable_entity",
     "get_publishable_entity_by_key",
+    "get_publishable_entities",
     "get_last_publish",
     "get_all_drafts",
     "get_entities_with_unpublished_changes",
@@ -69,7 +70,7 @@ __all__ = [
     "set_draft_version",
     "soft_delete_draft",
     "reset_drafts_to_published",
-    "register_content_models",
+    "register_publishable_models",
     "filter_publishable_entities",
     # 🛑 UNSTABLE: All APIs related to containers are unstable until we've figured
     #              out our approach to dynamic content (randomized, A/B tests, etc.)
@@ -261,6 +262,20 @@ def get_all_drafts(learning_package_id: int, /) -> QuerySet[Draft]:
     )
 
 
+def get_publishable_entities(learning_package_id: int, /) -> QuerySet[PublishableEntity]:
+    """
+    Get all entities in a learning package.
+    """
+    return (
+        PublishableEntity.objects
+        .filter(learning_package_id=learning_package_id)
+        .select_related(
+            "draft__version",
+            "published__version",
+        )
+    )
+
+
 def get_entities_with_unpublished_changes(
     learning_package_id: int,
     /,
@@ -417,15 +432,22 @@ def publish_from_drafts(
     return publish_log
 
 
-def get_draft_version(publishable_entity_id: int, /) -> PublishableEntityVersion | None:
+def get_draft_version(publishable_entity_or_id: PublishableEntity | int, /) -> PublishableEntityVersion | None:
     """
     Return current draft PublishableEntityVersion for this PublishableEntity.
 
     This function will return None if there is no current draft.
     """
+    if isinstance(publishable_entity_or_id, PublishableEntity):
+        # Fetches the draft version for a given PublishableEntity.
+        # Gracefully handles cases where no draft is present.
+        draft: Optional[Draft] = getattr(publishable_entity_or_id, "draft", None)
+        if draft is None:
+            return None
+        return draft.version
     try:
         draft = Draft.objects.select_related("version").get(
-            entity_id=publishable_entity_id
+            entity_id=publishable_entity_or_id
         )
     except Draft.DoesNotExist:
         # No draft was ever created.
@@ -437,15 +459,22 @@ def get_draft_version(publishable_entity_id: int, /) -> PublishableEntityVersion
     return draft.version
 
 
-def get_published_version(publishable_entity_id: int, /) -> PublishableEntityVersion | None:
+def get_published_version(publishable_entity_or_id: PublishableEntity | int, /) -> PublishableEntityVersion | None:
     """
     Return current published PublishableEntityVersion for this PublishableEntity.
 
     This function will return None if there is no current published version.
     """
+    if isinstance(publishable_entity_or_id, PublishableEntity):
+        # Fetches the published version for a given PublishableEntity.
+        # Gracefully handles cases where no published version is present.
+        published: Optional[Published] = getattr(publishable_entity_or_id, "published", None)
+        if published is None:
+            return None
+        return published.version
     try:
         published = Published.objects.select_related("version").get(
-            entity_id=publishable_entity_id
+            entity_id=publishable_entity_or_id
         )
     except Published.DoesNotExist:
         return None
@@ -789,7 +818,7 @@ def reset_drafts_to_published(
             set_draft_version(draft, published_version_id)
 
 
-def register_content_models(
+def register_publishable_models(
     content_model_cls: type[PublishableEntityMixin],
     content_version_model_cls: type[PublishableEntityVersionMixin],
 ) -> PublishableContentModelRegistry:
@@ -805,10 +834,10 @@ def register_content_models(
     method. For example, in the components app, this looks like:
 
         def ready(self):
-            from ..publishing.api import register_content_models
+            from ..publishing.api import register_publishable_models
             from .models import Component, ComponentVersion
 
-            register_content_models(Component, ComponentVersion)
+            register_publishable_models(Component, ComponentVersion)
 
     There may be a more clever way to introspect this information from the model
     metadata, but this is simple and explicit.
@@ -1275,6 +1304,7 @@ def get_entities_in_container(
     container: Container,
     *,
     published: bool,
+    select_related_version: str | None = None,
 ) -> list[ContainerEntityListEntry]:
     """
     [ 🛑 UNSTABLE ]
@@ -1285,14 +1315,35 @@ def get_entities_in_container(
         container: The Container, e.g. returned by `get_container()`
         published: `True` if we want the published version of the container, or
             `False` for the draft version.
+        select_related_version: An optional optimization; specify a relationship
+        on ContainerVersion, like `componentversion` or `containerversion__x`
+        to preload via select_related.
     """
     assert isinstance(container, Container)
-    container_version = container.versioning.published if published else container.versioning.draft
+    if published:
+        # Very minor optimization: reload the container with related 1:1 entities
+        container = Container.objects.select_related(
+            "publishable_entity__published__version__containerversion__entity_list").get(pk=container.pk)
+        container_version = container.versioning.published
+        select_related = ["entity__published__version"]
+        if select_related_version:
+            select_related.append(f"entity__published__version__{select_related_version}")
+    else:
+        # Very minor optimization: reload the container with related 1:1 entities
+        container = Container.objects.select_related(
+            "publishable_entity__draft__version__containerversion__entity_list").get(pk=container.pk)
+        container_version = container.versioning.draft
+        select_related = ["entity__draft__version"]
+        if select_related_version:
+            select_related.append(f"entity__draft__version__{select_related_version}")
     if container_version is None:
         raise ContainerVersion.DoesNotExist  # This container has not been published yet, or has been deleted.
     assert isinstance(container_version, ContainerVersion)
-    entity_list = []
-    for row in container_version.entity_list.entitylistrow_set.order_by("order_num"):
+    entity_list: list[ContainerEntityListEntry] = []
+    for row in container_version.entity_list.entitylistrow_set.select_related(
+        "entity_version",
+        *select_related,
+    ).order_by("order_num"):
         entity_version = row.entity_version  # This will be set if pinned
         if not entity_version:  # If this entity is "unpinned", use the latest published/draft version:
             entity_version = row.entity.published.version if published else row.entity.draft.version
@@ -1385,7 +1436,10 @@ def get_containers_with_entity(
         qs = Container.objects.filter(
             publishable_entity__draft__version__containerversion__entity_list__entitylistrow__entity_id=publishable_entity_pk,  # pylint: disable=line-too-long # noqa: E501
         )
-    return qs.order_by("pk").distinct()  # Ordering is mostly for consistent test cases.
+    return qs.select_related(
+        "publishable_entity__draft__version__containerversion",
+        "publishable_entity__published__version__containerversion",
+    ).order_by("pk").distinct()  # Ordering is mostly for consistent test cases.
 
 
 def get_container_children_count(

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/publishing/apps.py

@@ -19,7 +19,7 @@ class PublishingConfig(AppConfig):
         """
         Register Container and ContainerVersion.
         """
-        from .api import register_content_models  # pylint: disable=import-outside-toplevel
+        from .api import register_publishable_models  # pylint: disable=import-outside-toplevel
         from .models import Container, ContainerVersion  # pylint: disable=import-outside-toplevel
 
-        register_content_models(Container, ContainerVersion)
+        register_publishable_models(Container, ContainerVersion)

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/publishing/models/publishable_entity.py

@@ -272,7 +272,7 @@ class PublishableEntityMixin(models.Model):
     Please see docstring for PublishableEntity for more details.
 
     If you use this class, you *MUST* also use PublishableEntityVersionMixin and
-    the publishing app's api.register_content_models (see its docstring for
+    the publishing app's api.register_publishable_models (see its docstring for
     details).
     """
     # select these related entities by default for all queries
@@ -294,6 +294,10 @@ class PublishableEntityMixin(models.Model):
     def uuid(self) -> str:
         return self.publishable_entity.uuid
 
+    @property
+    def can_stand_alone(self) -> bool:
+        return self.publishable_entity.can_stand_alone
+
     @property
     def key(self) -> str:
         return self.publishable_entity.key
@@ -551,7 +555,7 @@ class PublishableEntityVersionMixin(models.Model):
     Please see docstring for PublishableEntityVersion for more details.
 
     If you use this class, you *MUST* also use PublishableEntityMixin and the
-    publishing app's api.register_content_models (see its docstring for
+    publishing app's api.register_publishable_models (see its docstring for
     details).
     """
 
@@ -609,7 +613,7 @@ class PublishableContentModelRegistry:
         Register what content model maps to what content version model.
 
         If you want to call this from another app, please use the
-        ``register_content_models`` function in this app's ``api`` module
+        ``register_publishable_models`` function in this app's ``api`` module
         instead.
         """
         if not issubclass(content_model_cls, PublishableEntityMixin):

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/sections/api.py

@@ -257,7 +257,12 @@ def get_subsections_in_section(
     """
     assert isinstance(section, Section)
     subsections = []
-    for entry in publishing_api.get_entities_in_container(section, published=published):
+    entries = publishing_api.get_entities_in_container(
+        section,
+        published=published,
+        select_related_version="containerversion__subsectionversion",
+    )
+    for entry in entries:
         # Convert from generic PublishableEntityVersion to SubsectionVersion:
         subsection_version = entry.entity_version.containerversion.subsectionversion
         assert isinstance(subsection_version, SubsectionVersion)

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/sections/apps.py

@@ -19,7 +19,7 @@ class SectionsConfig(AppConfig):
         """
         Register Section and SectionVersion.
         """
-        from ..publishing.api import register_content_models  # pylint: disable=import-outside-toplevel
+        from ..publishing.api import register_publishable_models  # pylint: disable=import-outside-toplevel
         from .models import Section, SectionVersion  # pylint: disable=import-outside-toplevel
 
-        register_content_models(Section, SectionVersion)
+        register_publishable_models(Section, SectionVersion)

{openedx_learning-0.27.0 → openedx_learning-0.28.0}/openedx_learning/apps/authoring/subsections/api.py

@@ -256,7 +256,12 @@ def get_units_in_subsection(
     """
     assert isinstance(subsection, Subsection)
     units = []
-    for entry in publishing_api.get_entities_in_container(subsection, published=published):
+    entries = publishing_api.get_entities_in_container(
+        subsection,
+        published=published,
+        select_related_version="containerversion__unitversion",
+    )
+    for entry in entries:
         # Convert from generic PublishableEntityVersion to UnitVersion:
         unit_version = entry.entity_version.containerversion.unitversion
         assert isinstance(unit_version, UnitVersion)