openedx-learning 0.27.1__py2.py3-none-any.whl → 0.28.0__py2.py3-none-any.whl

openedx_learning/__init__.py

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

openedx_learning/apps/authoring/backup_restore/toml.py

@@ -6,6 +6,7 @@ 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
 
@@ -27,8 +28,8 @@ def toml_learning_package(learning_package: LearningPackage) -> str:
 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)
+    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()
@@ -37,12 +38,12 @@ def toml_publishable_entity(entity: PublishableEntity) -> str:
 
     if current_draft_version:
         draft_table = tomlkit.table()
-        draft_table.add("version_num", current_draft_version.version.version_num)
+        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.version_num)
+        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)

openedx_learning/apps/authoring/backup_restore/zipper.py

@@ -2,16 +2,54 @@
 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
-from openedx_learning.apps.authoring.publishing.models.learning_package import LearningPackage
 
 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.
@@ -19,6 +57,66 @@ class LearningPackageZipper:
 
     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:
         """
@@ -28,26 +126,117 @@ class LearningPackageZipper:
         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
+            # 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")
-            zip_info = zipfile.ZipInfo(str(entities_folder) + "/")  # Ensure trailing slash
-            zipf.writestr(zip_info, "")  # Add explicit empty directory entry
+            self.create_folder(entities_folder, zipf)
 
             # 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
+            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
 
-            # 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)
+
+                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/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,9 +58,9 @@ __all__ = [
     "create_publishable_entity_version",
     "get_publishable_entity",
     "get_publishable_entity_by_key",
+    "get_publishable_entities",
     "get_last_publish",
     "get_all_drafts",
-    "get_entities",
     "get_entities_with_unpublished_changes",
     "get_entities_with_unpublished_deletes",
     "publish_all_drafts",
@@ -262,11 +262,18 @@ def get_all_drafts(learning_package_id: int, /) -> QuerySet[Draft]:
     )
 
 
-def get_entities(learning_package_id: int, /) -> QuerySet[PublishableEntity]:
+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)
+    return (
+        PublishableEntity.objects
+        .filter(learning_package_id=learning_package_id)
+        .select_related(
+            "draft__version",
+            "published__version",
+        )
+    )
 
 
 def get_entities_with_unpublished_changes(
@@ -425,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.
@@ -445,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

{openedx_learning-0.27.1.dist-info → openedx_learning-0.28.0.dist-info}/METADATA

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

{openedx_learning-0.27.1.dist-info → openedx_learning-0.28.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-openedx_learning/__init__.py,sha256=yNCuSKMLv6YJnAu09cqc4GpR5uVIDaJP2-5z9RAWJeM,69
+openedx_learning/__init__.py,sha256=uNMwU0K5IBvKkVUxhRpjU7JmSuDVu7oR_QPr65ElCPE,69
 openedx_learning/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_learning/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_learning/api/authoring.py,sha256=EDWTY_JDKtjD9nFrrijzWuVccs3LZeDLEdzTUNanR4I,1111
@@ -10,8 +10,8 @@ openedx_learning/apps/authoring/backup_restore/admin.py,sha256=OnEixkOuysPRr-F6C
 openedx_learning/apps/authoring/backup_restore/api.py,sha256=zEns3crvfFEFFh7MmwzSqW0WuGmZaSgdmujzl0PnfvU,508
 openedx_learning/apps/authoring/backup_restore/apps.py,sha256=UnExBA7jhd3qI30_87JMvzVhS_k82t89qDVKSMpvg_A,340
 openedx_learning/apps/authoring/backup_restore/models.py,sha256=jlr0ppxW0IOW3HPHoJNChHvDrYVnKMb5_3uC2itxqQk,45
-openedx_learning/apps/authoring/backup_restore/toml.py,sha256=KRlOSln1wNB6U7qXXf6Cr9_GZrLUXLwH-x9Yxd9lmBk,2874
-openedx_learning/apps/authoring/backup_restore/zipper.py,sha256=6hX8qQFHS3HCAUs5JsxHuLUWOOa_6Y8c93WcAZKDE4A,2379
+openedx_learning/apps/authoring/backup_restore/toml.py,sha256=8D103aAfCtzVPV4U-yuB-HsXvNCO3cs3xhvMJTI4IXo,2955
+openedx_learning/apps/authoring/backup_restore/zipper.py,sha256=_SWgnfLHziFLWF-iXf_38L8v6C-yO8PjyZHxDCtaJ0k,11494
 openedx_learning/apps/authoring/backup_restore/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_learning/apps/authoring/backup_restore/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_learning/apps/authoring/backup_restore/management/commands/lp_dump.py,sha256=TkbyBf9Jsa7yoXiGEduO0ZqKTYO7vWGHbqr5NbEclRs,1696
@@ -48,7 +48,7 @@ openedx_learning/apps/authoring/contents/migrations/0001_initial.py,sha256=FtOTm
 openedx_learning/apps/authoring/contents/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_learning/apps/authoring/publishing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_learning/apps/authoring/publishing/admin.py,sha256=nvAAl3Xswqqq3WyaI1NT7pLCcu1o-ynciJZOlc-9L24,16244
-openedx_learning/apps/authoring/publishing/api.py,sha256=rLwS_Ma1Yp5bryR5-gTllIot6AjFB5g-7UFUxZtJsPU,57208
+openedx_learning/apps/authoring/publishing/api.py,sha256=yNHqupNDY4FPNmQYnwMr1Sey_t85CjrpYpNDFh9nfF8,58162
 openedx_learning/apps/authoring/publishing/apps.py,sha256=PXYIx-TwN7a8dDudodX80Z7hNV9bWzrMZnpDET8lCGE,758
 openedx_learning/apps/authoring/publishing/contextmanagers.py,sha256=AH5zhr0Tz_gUG9--dfr_oZAu8DMy94n6mnOJuPbWkeU,6723
 openedx_learning/apps/authoring/publishing/migrations/0001_initial.py,sha256=wvekNV19YRSdxRmQaFnLSn_nCsQlHIucPDVMmgKf_OE,9272
@@ -101,7 +101,7 @@ openedx_learning/lib/fields.py,sha256=eiGoXMPhRuq25EH2qf6BAODshAQE3DBVdIYAMIUAXW
 openedx_learning/lib/managers.py,sha256=-Q3gxalSqyPZ9Im4DTROW5tF8wVTZLlmfTe62_xmowY,1643
 openedx_learning/lib/test_utils.py,sha256=g3KLuepIZbaDBCsaj9711YuqyUx7LD4gXDcfNC-mWdc,527
 openedx_learning/lib/validators.py,sha256=iqEdEAvFV2tC7Ecssx69kjecpdU8nE87AlDJYrqrsnc,404
-openedx_learning-0.27.1.dist-info/licenses/LICENSE.txt,sha256=QTW2QN7q3XszgUAXm9Dzgtu5LXYKbR1SGnqMa7ufEuY,35139
+openedx_learning-0.28.0.dist-info/licenses/LICENSE.txt,sha256=QTW2QN7q3XszgUAXm9Dzgtu5LXYKbR1SGnqMa7ufEuY,35139
 openedx_tagging/__init__.py,sha256=V9N8M7f9LYlAbA_DdPUsHzTnWjYRXKGa5qHw9P1JnNI,30
 openedx_tagging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_tagging/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -146,7 +146,7 @@ openedx_tagging/core/tagging/models/__init__.py,sha256=yYdOnthuc7EUdfEULtZgqRwn5
 openedx_tagging/core/tagging/models/base.py,sha256=ju4mvgRS_I2AgPsRf4sMFy6qle2i0aA0MbyBYZXf32g,39685
 openedx_tagging/core/tagging/models/import_export.py,sha256=Aj0pleh0nh2LNS6zmdB1P4bpdgUMmvmobTkqBerORAI,4570
 openedx_tagging/core/tagging/models/system_defined.py,sha256=_6LfvUZGEltvQMtm2OXy6TOLh3C8GnVTqtZDSAZW6K4,9062
-openedx_tagging/core/tagging/models/utils.py,sha256=-A3Dj24twmTf65UB7G4WLvb_9qEvduEPIwahZ-FJDlg,1926
+openedx_tagging/core/tagging/models/utils.py,sha256=x2dg3IYE3RVOZtInkwKtznHcByDmc2R-sBMVWksHnjs,2917
 openedx_tagging/core/tagging/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openedx_tagging/core/tagging/rest_api/paginators.py,sha256=BUIAg3taihHx7uAjpTZAGK1xSZzZY9G0aib4OKv5c0k,2651
 openedx_tagging/core/tagging/rest_api/urls.py,sha256=egXaRQv1EAgF04ThgVZBQuvLK1LimuyUKKBD2Hbqb10,148
@@ -157,7 +157,7 @@ openedx_tagging/core/tagging/rest_api/v1/serializers.py,sha256=0HQD_Jrf6-YpocYfz
 openedx_tagging/core/tagging/rest_api/v1/urls.py,sha256=dNUKCtUCx_YzrwlbEbpDfjGVQbb2QdJ1VuJCkladj6E,752
 openedx_tagging/core/tagging/rest_api/v1/views.py,sha256=Hf92cy-tE767DE9FgsZcPKiCYrf5ihfETz8qGKBnuiU,36278
 openedx_tagging/core/tagging/rest_api/v1/views_import.py,sha256=kbHUPe5A6WaaJ3J1lFIcYCt876ecLNQfd19m7YYub6c,1470
-openedx_learning-0.27.1.dist-info/METADATA,sha256=0otM32S0-1Xf6yX0mjj-P2xAOiU_k5VhIQtVpL1WMos,9055
-openedx_learning-0.27.1.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-openedx_learning-0.27.1.dist-info/top_level.txt,sha256=IYFbr5mgiEHd-LOtZmXj3q3a0bkGK1M9LY7GXgnfi4M,33
-openedx_learning-0.27.1.dist-info/RECORD,,
+openedx_learning-0.28.0.dist-info/METADATA,sha256=2B4GnwRZKKZfm9RmEkeJITaAaGGHi4lfvnhPkW8a5Jk,9055
+openedx_learning-0.28.0.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+openedx_learning-0.28.0.dist-info/top_level.txt,sha256=IYFbr5mgiEHd-LOtZmXj3q3a0bkGK1M9LY7GXgnfi4M,33
+openedx_learning-0.28.0.dist-info/RECORD,,

openedx_tagging/core/tagging/models/utils.py

@@ -1,8 +1,9 @@
 """
 Utilities for tagging and taxonomy models
 """
-from django.db.models import Aggregate, CharField
-from django.db.models.expressions import Func
+from django.db import connection as db_connection
+from django.db.models import Aggregate, CharField, TextField
+from django.db.models.expressions import Combinable, Func
 
 RESERVED_TAG_CHARS = [
     '\t',  # Used in the database to separate tag levels in the "lineage" field
@@ -34,21 +35,48 @@ class ConcatNull(Func):  # pylint: disable=abstract-method
         )
 
 
-class StringAgg(Aggregate):  # pylint: disable=abstract-method
+class StringAgg(Aggregate, Combinable):
     """
     Aggregate function that collects the values of some column across all rows,
-    and creates a string by concatenating those values, with "," as a separator.
+    and creates a string by concatenating those values, with a specified separator.
 
-    This is the same as Django's django.contrib.postgres.aggregates.StringAgg,
-    but this version works with MySQL and SQLite.
+    This version supports PostgreSQL (STRING_AGG), MySQL (GROUP_CONCAT), and SQLite.
     """
+    # Default function is for MySQL (GROUP_CONCAT)
     function = 'GROUP_CONCAT'
     template = '%(function)s(%(distinct)s%(expressions)s)'
 
-    def __init__(self, expression, distinct=False, **extra):
+    def __init__(self, expression, distinct=False, delimiter=',', **extra):
+        self.delimiter = delimiter
+        # Handle the distinct option and output type
+        distinct_str = 'DISTINCT ' if distinct else ''
+
+        extra.update({
+            'distinct': distinct_str,
+            'output_field': CharField(),
+        })
+
+        # Check the database backend (PostgreSQL, MySQL, or SQLite)
+        if 'postgresql' in db_connection.vendor.lower():
+            self.function = 'STRING_AGG'
+            self.template = '%(function)s(%(distinct)s%(expressions)s, %(delimiter)s)'
+            extra.update({
+                "delimiter": self.delimiter,
+                "output_field": TextField(),
+            })
+
+        # Initialize the parent class with the necessary parameters
         super().__init__(
             expression,
-            distinct='DISTINCT ' if distinct else '',
-            output_field=CharField(),
             **extra,
         )
+
+    # Implementing abstract methods from Combinable
+    def __rand__(self, other):
+        return self._combine(other, 'AND', False)
+
+    def __ror__(self, other):
+        return self._combine(other, 'OR', False)
+
+    def __rxor__(self, other):
+        return self._combine(other, 'XOR', False)