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

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

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

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

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

{openedx_learning-0.27.0 → openedx_learning-0.27.1}/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.27.1/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.27.1}/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.27.1/openedx_learning/apps/authoring/backup_restore/toml.py

@@ -0,0 +1,75 @@
+"""
+TOML serialization for learning packages and publishable entities.
+"""
+
+from datetime import datetime
+
+import tomlkit
+
+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 = getattr(entity, "draft", None)
+    current_published_version = getattr(entity, "published", None)
+
+    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.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.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.27.1/openedx_learning/apps/authoring/backup_restore/zipper.py

@@ -0,0 +1,53 @@
+"""
+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 zipfile
+from pathlib import Path
+
+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
+from openedx_learning.apps.authoring.publishing.models.learning_package import LearningPackage
+
+TOML_PACKAGE_NAME = "package.toml"
+
+
+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
+
+    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.
+        """
+        package_toml_content: str = toml_learning_package(self.learning_package)
+
+        with zipfile.ZipFile(path, "w", compression=zipfile.ZIP_DEFLATED) as zipf:
+            # Add the package.toml string
+            zipf.writestr(TOML_PACKAGE_NAME, package_toml_content)
+
+            # Add the entities directory
+            entities_folder = Path("entities")
+            zip_info = zipfile.ZipInfo(str(entities_folder) + "/")  # Ensure trailing slash
+            zipf.writestr(zip_info, "")  # Add explicit empty directory entry
+
+            # Add the collections directory
+            collections_folder = Path("collections")
+            collections_info = zipfile.ZipInfo(str(collections_folder) + "/")  # Ensure trailing slash
+            zipf.writestr(collections_info, "")  # Add explicit empty directory
+
+            # Add each entity's TOML file
+            for entity in publishing_api.get_entities(self.learning_package.pk):
+                # Create a TOML representation of the entity
+                entity_toml_content: str = toml_publishable_entity(entity)
+                entity_toml_filename = f"{entity.key}.toml"
+                entity_toml_path = entities_folder / entity_toml_filename
+                zipf.writestr(str(entity_toml_path), entity_toml_content)

{openedx_learning-0.27.0 → openedx_learning-0.27.1}/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.27.1}/openedx_learning/apps/authoring/publishing/api.py

@@ -60,6 +60,7 @@ __all__ = [
     "get_publishable_entity_by_key",
     "get_last_publish",
     "get_all_drafts",
+    "get_entities",
     "get_entities_with_unpublished_changes",
     "get_entities_with_unpublished_deletes",
     "publish_all_drafts",
@@ -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,13 @@ def get_all_drafts(learning_package_id: int, /) -> QuerySet[Draft]:
     )
 
 
+def get_entities(learning_package_id: int, /) -> QuerySet[PublishableEntity]:
+    """
+    Get all entities in a learning package.
+    """
+    return PublishableEntity.objects.filter(learning_package_id=learning_package_id)
+
+
 def get_entities_with_unpublished_changes(
     learning_package_id: int,
     /,
@@ -789,7 +797,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 +813,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 +1283,7 @@ def get_entities_in_container(
     container: Container,
     *,
     published: bool,
+    select_related_version: str | None = None,
 ) -> list[ContainerEntityListEntry]:
     """
     [ 🛑 UNSTABLE ]
@@ -1285,14 +1294,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 +1415,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.27.1}/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.27.1}/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.27.1}/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.27.1}/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.27.1}/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)

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

@@ -19,7 +19,7 @@ class SubsectionsConfig(AppConfig):
         """
         Register Subsection and SubsectionVersion.
         """
-        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 Subsection, SubsectionVersion  # pylint: disable=import-outside-toplevel
 
-        register_content_models(Subsection, SubsectionVersion)
+        register_publishable_models(Subsection, SubsectionVersion)

{openedx_learning-0.27.0 → openedx_learning-0.27.1}/openedx_learning/apps/authoring/units/api.py

@@ -257,7 +257,12 @@ def get_components_in_unit(
     """
     assert isinstance(unit, Unit)
     components = []
-    for entry in publishing_api.get_entities_in_container(unit, published=published):
+    entries = publishing_api.get_entities_in_container(
+        unit,
+        published=published,
+        select_related_version="componentversion",
+    )
+    for entry in entries:
         # Convert from generic PublishableEntityVersion to ComponentVersion:
         component_version = entry.entity_version.componentversion
         assert isinstance(component_version, ComponentVersion)

{openedx_learning-0.27.0 → openedx_learning-0.27.1}/openedx_learning/apps/authoring/units/apps.py

@@ -19,7 +19,7 @@ class UnitsConfig(AppConfig):
         """
         Register Unit and UnitVersion.
         """
-        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 Unit, UnitVersion  # pylint: disable=import-outside-toplevel
 
-        register_content_models(Unit, UnitVersion)
+        register_publishable_models(Unit, UnitVersion)

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

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

{openedx_learning-0.27.0 → openedx_learning-0.27.1}/openedx_learning.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ openedx_learning/apps/authoring/backup_restore/api.py
 openedx_learning/apps/authoring/backup_restore/apps.py
 openedx_learning/apps/authoring/backup_restore/models.py
 openedx_learning/apps/authoring/backup_restore/toml.py
+openedx_learning/apps/authoring/backup_restore/zipper.py
 openedx_learning/apps/authoring/backup_restore/management/__init__.py
 openedx_learning/apps/authoring/backup_restore/management/commands/__init__.py
 openedx_learning/apps/authoring/backup_restore/management/commands/lp_dump.py

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

@@ -1,25 +0,0 @@
-"""
-Backup Restore API
-"""
-import zipfile
-
-from openedx_learning.apps.authoring.publishing.api import get_learning_package_by_key
-
-from .toml import TOMLLearningPackageFile
-
-TOML_PACKAGE_NAME = "package.toml"
-
-
-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)
-    toml_file = TOMLLearningPackageFile(learning_package)
-    toml_file.create()
-    toml_content: str = toml_file.get()
-    with zipfile.ZipFile(path, "w", compression=zipfile.ZIP_DEFLATED) as zipf:
-        # Add the TOML string as a file in the ZIP
-        zipf.writestr(TOML_PACKAGE_NAME, toml_content)

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

@@ -1,72 +0,0 @@
-"""
-Utilities for backup and restore app
-"""
-
-from datetime import datetime
-from typing import Any, Dict
-
-from tomlkit import comment, document, dumps, nl, table
-from tomlkit.items import Table
-
-from openedx_learning.apps.authoring.publishing.models.learning_package import LearningPackage
-
-
-class TOMLLearningPackageFile():
-    """
-    Class to create a .toml representation of a LearningPackage instance.
-
-    This class builds a structured TOML document using `tomlkit` with metadata and fields
-    extracted from a `LearningPackage` object. The output can later be saved to a file or used elsewhere.
-    """
-
-    def __init__(self, learning_package: LearningPackage):
-        self.doc = document()
-        self.learning_package = learning_package
-
-    def _create_header(self) -> None:
-        """
-        Adds a comment with the current datetime to indicate when the export occurred.
-        This helps with traceability and file versioning.
-        """
-        self.doc.add(comment(f"Datetime of the export: {datetime.now()}"))
-        self.doc.add(nl())
-
-    def _create_table(self, params: Dict[str, Any]) -> Table:
-        """
-        Builds a TOML table section from a dictionary of key-value pairs.
-
-        Args:
-            params (Dict[str, Any]): A dictionary containing keys and values to include in the TOML table.
-
-        Returns:
-            Table: A TOML table populated with the provided keys and values.
-        """
-        section = table()
-        for key, value in params.items():
-            section.add(key, value)
-        return section
-
-    def create(self) -> None:
-        """
-        Populates the TOML document with a header and a table containing
-        metadata from the LearningPackage instance.
-
-        This method must be called before calling `get()`, otherwise the document will be empty.
-        """
-        self._create_header()
-        section = self._create_table({
-            "title": self.learning_package.title,
-            "key": self.learning_package.key,
-            "description": self.learning_package.description,
-            "created": self.learning_package.created,
-            "updated": self.learning_package.updated
-        })
-        self.doc.add("learning_package", section)
-
-    def get(self) -> str:
-        """
-        Returns:
-            str: The string representation of the generated TOML document.
-            Ensure `create()` has been called beforehand to get meaningful output.
-        """
-        return dumps(self.doc)