openedx-learning 0.5.1__py2.py3-none-any.whl → 0.6.1__py2.py3-none-any.whl

openedx_learning/__init__.py

@@ -1,4 +1,4 @@
 """
 Open edX Learning ("Learning Core").
 """
-__version__ = "0.5.1"
+__version__ = "0.6.1"

openedx_learning/contrib/media_server/views.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
 from django.http import FileResponse, Http404
 
-from openedx_learning.core.components.api import get_component_version_content
+from openedx_learning.core.components.api import look_up_component_version_content
 
 
 def component_asset(
@@ -28,7 +28,7 @@ def component_asset(
     * Serving from a different domain than the rest of the service
     """
     try:
-        cvc = get_component_version_content(
+        cvc = look_up_component_version_content(
             learning_package_key, component_key, version_num, asset_path
         )
     except ObjectDoesNotExist:

openedx_learning/core/components/admin.py

@@ -9,7 +9,7 @@ from django.utils.safestring import SafeText
 
 from openedx_learning.lib.admin_utils import ReadOnlyModelAdmin
 
-from .models import Component, ComponentVersion, ComponentVersionRawContent
+from .models import Component, ComponentVersion, ComponentVersionContent
 
 
 class ComponentVersionInline(admin.TabularInline):
@@ -48,18 +48,18 @@ class ComponentAdmin(ReadOnlyModelAdmin):
     inlines = [ComponentVersionInline]
 
 
-class RawContentInline(admin.TabularInline):
+class ContentInline(admin.TabularInline):
     """
-    Django admin configuration for RawContent
+    Django admin configuration for Content
     """
-    model = ComponentVersion.raw_contents.through
+    model = ComponentVersion.contents.through
 
     def get_queryset(self, request):
         queryset = super().get_queryset(request)
         return queryset.select_related(
-            "raw_content",
-            "raw_content__learning_package",
-            "raw_content__text_content",
+            "content",
+            "content__learning_package",
+            "content__media_type",
             "component_version",
             "component_version__publishable_entity_version",
             "component_version__component",
@@ -73,7 +73,7 @@ class RawContentInline(admin.TabularInline):
         "rendered_data",
     ]
     readonly_fields = [
-        "raw_content",
+        "content",
         "format_key",
         "format_size",
         "rendered_data",
@@ -85,7 +85,7 @@ class RawContentInline(admin.TabularInline):
 
     @admin.display(description="Size")
     def format_size(self, cvc_obj):
-        return filesizeformat(cvc_obj.raw_content.size)
+        return filesizeformat(cvc_obj.content.size)
 
     @admin.display(description="Key")
     def format_key(self, cvc_obj):
@@ -108,7 +108,7 @@ class ComponentVersionAdmin(ReadOnlyModelAdmin):
         "title",
         "version_num",
         "created",
-        "raw_contents",
+        "contents",
     ]
     fields = [
         "component",
@@ -118,7 +118,7 @@ class ComponentVersionAdmin(ReadOnlyModelAdmin):
         "created",
     ]
     list_display = ["component", "version_num", "uuid", "created"]
-    inlines = [RawContentInline]
+    inlines = [ContentInline]
 
     def get_queryset(self, request):
         queryset = super().get_queryset(request)
@@ -129,12 +129,12 @@ class ComponentVersionAdmin(ReadOnlyModelAdmin):
         )
 
 
-def link_for_cvc(cvc_obj: ComponentVersionRawContent) -> str:
+def link_for_cvc(cvc_obj: ComponentVersionContent) -> str:
     """
-    Get the download URL for the given ComponentVersionRawContent instance
+    Get the download URL for the given ComponentVersionContent instance
     """
     return "/media_server/component_asset/{}/{}/{}/{}".format(
-        cvc_obj.raw_content.learning_package.key,
+        cvc_obj.content.learning_package.key,
         cvc_obj.component_version.component.key,
         cvc_obj.component_version.version_num,
         cvc_obj.key,
@@ -151,27 +151,18 @@ def format_text_for_admin_display(text: str) -> SafeText:
     )
 
 
-def content_preview(cvc_obj: ComponentVersionRawContent) -> SafeText:
+def content_preview(cvc_obj: ComponentVersionContent) -> SafeText:
     """
-    Get the HTML to display a preview of the given ComponentVersionRawContent
+    Get the HTML to display a preview of the given ComponentVersionContent
     """
-    raw_content_obj = cvc_obj.raw_content
+    content_obj = cvc_obj.content
 
-    if raw_content_obj.media_type.type == "image":
+    if content_obj.media_type.type == "image":
         return format_html(
             '<img src="{}" style="max-width: 100%;" />',
-            # TODO: configure with settings value:
-            "/media_server/component_asset/{}/{}/{}/{}".format(
-                cvc_obj.raw_content.learning_package.key,
-                cvc_obj.component_version.component.key,
-                cvc_obj.component_version.version_num,
-                cvc_obj.key,
-            ),
+            content_obj.file_url(),
         )
 
-    if hasattr(raw_content_obj, "text_content"):
-        return format_text_for_admin_display(
-            raw_content_obj.text_content.text,
-        )
-
-    return format_html("This content type cannot be displayed.")
+    return format_text_for_admin_display(
+        content_obj.text or ""
+    )

openedx_learning/core/components/api.py

@@ -18,28 +18,32 @@ from pathlib import Path
 from django.db.models import Q, QuerySet
 from django.db.transaction import atomic
 
-from ...lib.cache import lru_cache
 from ..publishing import api as publishing_api
-from .models import Component, ComponentType, ComponentVersion, ComponentVersionRawContent
+from .models import Component, ComponentType, ComponentVersion, ComponentVersionContent
 
 
-@lru_cache(maxsize=128)
-def get_or_create_component_type_id(namespace: str, name: str) -> int:
+def get_or_create_component_type(namespace: str, name: str) -> ComponentType:
     """
     Get the ID of a ComponentType, and create if missing.
+
+    Caching Warning: Be careful about putting any caching decorator around this
+    function (e.g. ``lru_cache``). It's possible that incorrect cache values
+    could leak out in the event of a rollback–e.g. new types are introduced in
+    a large import transaction which later fails. You can safely cache the
+    results that come back from this function with a local dict in your import
+    process instead.#
     """
     component_type, _created = ComponentType.objects.get_or_create(
         namespace=namespace,
         name=name,
     )
-    return component_type.id
+    return component_type
 
 
 def create_component(
     learning_package_id: int,
     /,
-    namespace: str,
-    type_name: str,
+    component_type: ComponentType,
     local_key: str,
     created: datetime,
     created_by: int | None,
@@ -47,7 +51,7 @@ def create_component(
     """
     Create a new Component (an entity like a Problem or Video)
     """
-    key = f"{namespace}:{type_name}@{local_key}"
+    key = f"{component_type.namespace}:{component_type.name}:{local_key}"
     with atomic():
         publishable_entity = publishing_api.create_publishable_entity(
             learning_package_id, key, created, created_by
@@ -55,7 +59,7 @@ def create_component(
         component = Component.objects.create(
             publishable_entity=publishable_entity,
             learning_package_id=learning_package_id,
-            component_type_id=get_or_create_component_type_id(namespace, type_name),
+            component_type=component_type,
             local_key=local_key,
         )
     return component
@@ -101,10 +105,10 @@ def create_next_version(
     A very common pattern for making a new ComponentVersion is going to be "make
     it just like the last version, except changing these one or two things".
     Before calling this, you should create any new contents via the contents
-    API, since ``content_to_replace`` needs RawContent IDs for the values.
+    API, since ``content_to_replace`` needs Content IDs for the values.
 
     The ``content_to_replace`` dict is a mapping of strings representing the
-    local path/key for a file, to ``RawContent.id`` values. Using a `None` for
+    local path/key for a file, to ``Content.id`` values. Using a `None` for
     a value in this dict means to delete that key in the next version.
 
     It is okay to mark entries for deletion that don't exist. For instance, if a
@@ -144,25 +148,25 @@ def create_next_version(
             component_id=component_pk,
         )
         # First copy the new stuff over...
-        for key, raw_content_pk in content_to_replace.items():
-            # If the raw_content_pk is None, it means we want to remove the
+        for key, content_pk in content_to_replace.items():
+            # If the 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,
+            # we add our key->content_pk mapping to the next version.
+            if content_pk is not None:
+                ComponentVersionContent.objects.create(
+                    content_id=content_pk,
                     component_version=component_version,
                     key=key,
                     learner_downloadable=False,
                 )
         # Now copy any old associations that existed, as long as they aren't
         # in conflict with the new stuff or marked for deletion.
-        last_version_content_mapping = ComponentVersionRawContent.objects \
-                                                                 .filter(component_version=last_version)
+        last_version_content_mapping = ComponentVersionContent.objects \
+                                                              .filter(component_version=last_version)
         for cvrc in last_version_content_mapping:
             if cvrc.key not in content_to_replace:
-                ComponentVersionRawContent.objects.create(
-                    raw_content_id=cvrc.raw_content_id,
+                ComponentVersionContent.objects.create(
+                    content_id=cvrc.content_id,
                     component_version=component_version,
                     key=cvrc.key,
                     learner_downloadable=cvrc.learner_downloadable,
@@ -174,8 +178,7 @@ def create_next_version(
 def create_component_and_version(
     learning_package_id: int,
     /,
-    namespace: str,
-    type_name: str,
+    component_type: ComponentType,
     local_key: str,
     title: str,
     created: datetime,
@@ -186,7 +189,7 @@ def create_component_and_version(
     """
     with atomic():
         component = create_component(
-            learning_package_id, namespace, type_name, local_key, created, created_by
+            learning_package_id, component_type, local_key, created, created_by
         )
         component_version = create_component_version(
             component.pk,
@@ -282,27 +285,29 @@ def get_components(
         qset = qset.filter(component_type__name__in=type_names)
     if draft_title is not None:
         qset = qset.filter(
-            publishable_entity__draft__version__title__icontains=draft_title
+            Q(publishable_entity__draft__version__title__icontains=draft_title) |
+            Q(local_key__icontains=draft_title)
         )
     if published_title is not None:
         qset = qset.filter(
-            publishable_entity__published__version__title__icontains=published_title
+            Q(publishable_entity__published__version__title__icontains=published_title) |
+            Q(local_key__icontains=published_title)
         )
 
     return qset
 
 
-def get_component_version_content(
+def look_up_component_version_content(
     learning_package_key: str,
     component_key: str,
     version_num: int,
     key: Path,
-) -> ComponentVersionRawContent:
+) -> ComponentVersionContent:
     """
-    Look up ComponentVersionRawContent by human readable keys.
+    Look up ComponentVersionContent by human readable keys.
 
     Can raise a django.core.exceptions.ObjectDoesNotExist error if there is no
-    matching ComponentVersionRawContent.
+    matching ComponentVersionContent.
     """
     queries = (
         Q(component_version__component__learning_package__key=learning_package_key)
@@ -310,30 +315,29 @@ def get_component_version_content(
         & 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(queries)
-
-
-def add_content_to_component_version(
+    return ComponentVersionContent.objects \
+                                  .select_related(
+                                      "content",
+                                      "content__media_type",
+                                      "component_version",
+                                      "component_version__component",
+                                      "component_version__component__learning_package",
+                                  ).get(queries)
+
+
+def create_component_version_content(
     component_version_id: int,
+    content_id: int,
     /,
-    raw_content_id: int,
     key: str,
     learner_downloadable=False,
-) -> ComponentVersionRawContent:
+) -> ComponentVersionContent:
     """
-    Add a RawContent to the given ComponentVersion
+    Add a Content to the given ComponentVersion
     """
-    cvrc, _created = ComponentVersionRawContent.objects.get_or_create(
+    cvrc, _created = ComponentVersionContent.objects.get_or_create(
         component_version_id=component_version_id,
-        raw_content_id=raw_content_id,
+        content_id=content_id,
         key=key,
         learner_downloadable=learner_downloadable,
     )

openedx_learning/core/components/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 3.2.23 on 2024-01-31 05:34
+# Generated by Django 3.2.23 on 2024-02-06 03:23
 
 import uuid
 
@@ -13,8 +13,8 @@ class Migration(migrations.Migration):
     initial = True
 
     dependencies = [
-        ('oel_publishing', '0001_initial'),
         ('oel_contents', '0001_initial'),
+        ('oel_publishing', '0001_initial'),
     ]
 
     operations = [
@@ -49,20 +49,20 @@ class Migration(migrations.Migration):
             },
         ),
         migrations.CreateModel(
-            name='ComponentVersionRawContent',
+            name='ComponentVersionContent',
             fields=[
                 ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                 ('uuid', models.UUIDField(default=uuid.uuid4, editable=False, unique=True, verbose_name='UUID')),
                 ('key', openedx_learning.lib.fields.MultiCollationCharField(db_collations={'mysql': 'utf8mb4_bin', 'sqlite': 'BINARY'}, max_length=500)),
                 ('learner_downloadable', models.BooleanField(default=False)),
                 ('component_version', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='oel_components.componentversion')),
-                ('raw_content', models.ForeignKey(on_delete=django.db.models.deletion.RESTRICT, to='oel_contents.rawcontent')),
+                ('content', models.ForeignKey(on_delete=django.db.models.deletion.RESTRICT, to='oel_contents.content')),
             ],
         ),
         migrations.AddField(
             model_name='componentversion',
-            name='raw_contents',
-            field=models.ManyToManyField(related_name='component_versions', through='oel_components.ComponentVersionRawContent', to='oel_contents.RawContent'),
+            name='contents',
+            field=models.ManyToManyField(related_name='component_versions', through='oel_components.ComponentVersionContent', to='oel_contents.Content'),
         ),
         migrations.AddField(
             model_name='component',
@@ -75,16 +75,16 @@ class Migration(migrations.Migration):
             field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='oel_publishing.learningpackage'),
         ),
         migrations.AddIndex(
-            model_name='componentversionrawcontent',
-            index=models.Index(fields=['raw_content', 'component_version'], name='oel_cvrawcontent_c_cv'),
+            model_name='componentversioncontent',
+            index=models.Index(fields=['content', 'component_version'], name='oel_cvcontent_c_cv'),
         ),
         migrations.AddIndex(
-            model_name='componentversionrawcontent',
-            index=models.Index(fields=['component_version', 'raw_content'], name='oel_cvrawcontent_cv_d'),
+            model_name='componentversioncontent',
+            index=models.Index(fields=['component_version', 'content'], name='oel_cvcontent_cv_d'),
         ),
         migrations.AddConstraint(
-            model_name='componentversionrawcontent',
-            constraint=models.UniqueConstraint(fields=('component_version', 'key'), name='oel_cvrawcontent_uniq_cv_key'),
+            model_name='componentversioncontent',
+            constraint=models.UniqueConstraint(fields=('component_version', 'key'), name='oel_cvcontent_uniq_cv_key'),
         ),
         migrations.AddIndex(
             model_name='component',

openedx_learning/core/components/migrations/0002_alter_componentversioncontent_key.py

@@ -0,0 +1,20 @@
+# Generated by Django 4.2.10 on 2024-02-14 22:02
+
+from django.db import migrations
+
+import openedx_learning.lib.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('oel_components', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='componentversioncontent',
+            name='key',
+            field=openedx_learning.lib.fields.MultiCollationCharField(db_collations={'mysql': 'utf8mb4_bin', 'sqlite': 'BINARY'}, db_column='_key', max_length=500),
+        ),
+    ]

openedx_learning/core/components/models.py

@@ -1,5 +1,5 @@
 """
-The model hierarchy is Component -> ComponentVersion -> RawContent.
+The model hierarchy is Component -> ComponentVersion -> Content.
 
 A Component is an entity like a Problem or Video. It has enough information to
 identify the Component and determine what the handler should be (e.g. XBlock
@@ -10,20 +10,18 @@ that Component. Managing the publishing of these versions is handled through the
 publishing app. Component maps 1:1 to PublishableEntity and ComponentVersion
 maps 1:1 to PublishableEntityVersion.
 
-Multiple pieces of RawContent may be associated with a ComponentVersion, through
-the ComponentVersionRawContent model. ComponentVersionRawContent allows to
-specify a ComponentVersion-local identifier. We're using this like a file path
-by convention, but it's possible we might want to have special identifiers
-later.
+Multiple pieces of Content may be associated with a ComponentVersion, through
+the ComponentVersionContent model. ComponentVersionContent allows to specify a
+ComponentVersion-local identifier. We're using this like a file path by
+convention, but it's possible we might want to have special identifiers later.
 """
 from __future__ import annotations
 
 from django.db import models
 
-from openedx_learning.lib.fields import case_sensitive_char_field, immutable_uuid_field, key_field
-from openedx_learning.lib.managers import WithRelationsManager
-
-from ..contents.models import RawContent
+from ...lib.fields import case_sensitive_char_field, immutable_uuid_field, key_field
+from ...lib.managers import WithRelationsManager
+from ..contents.models import Content
 from ..publishing.model_mixins import PublishableEntityMixin, PublishableEntityVersionMixin
 from ..publishing.models import LearningPackage
 
@@ -40,6 +38,10 @@ class ComponentType(models.Model):
     type of Components–e.g. marking certain types of XBlocks as approved vs.
     experimental for use in libraries.
     """
+    # We don't need the app default of 8-bytes for this primary key, but there
+    # is just a tiny chance that we'll use ComponentType in a novel, user-
+    # customizable way that will require more than 32K entries. So let's use a
+    # 4-byte primary key.
     id = models.AutoField(primary_key=True)
 
     # namespace and name work together to help figure out what Component needs
@@ -79,7 +81,7 @@ class Component(PublishableEntityMixin):  # type: ignore[django-manager-missing]
     Problem), but little beyond that.
 
     A Component will have many ComponentVersions over time, and most metadata is
-    associated with the ComponentVersion model and the RawContent that
+    associated with the ComponentVersion model and the Content that
     ComponentVersions are associated with.
 
     A Component belongs to exactly one LearningPackage.
@@ -187,8 +189,8 @@ class ComponentVersion(PublishableEntityVersionMixin):
     """
     A particular version of a Component.
 
-    This holds the content using a M:M relationship with RawContent via
-    ComponentVersionRawContent.
+    This holds the content using a M:M relationship with Content via
+    ComponentVersionContent.
     """
     # Tell mypy what type our objects manager has.
     # It's actually PublishableEntityVersionMixinManager, but that has the exact
@@ -202,11 +204,11 @@ class ComponentVersion(PublishableEntityVersionMixin):
         Component, on_delete=models.CASCADE, related_name="versions"
     )
 
-    # The raw_contents hold the actual interesting data associated with this
+    # The contents hold the actual interesting data associated with this
     # ComponentVersion.
-    raw_contents: models.ManyToManyField[RawContent, ComponentVersionRawContent] = models.ManyToManyField(
-        RawContent,
-        through="ComponentVersionRawContent",
+    contents: models.ManyToManyField[Content, ComponentVersionContent] = models.ManyToManyField(
+        Content,
+        through="ComponentVersionContent",
         related_name="component_versions",
     )
 
@@ -215,32 +217,37 @@ class ComponentVersion(PublishableEntityVersionMixin):
         verbose_name_plural = "Component Versions"
 
 
-class ComponentVersionRawContent(models.Model):
+class ComponentVersionContent(models.Model):
     """
-    Determines the RawContent for a given ComponentVersion.
+    Determines the Content for a given ComponentVersion.
 
     An ComponentVersion may be associated with multiple pieces of binary data.
     For instance, a Video ComponentVersion might be associated with multiple
     transcripts in different languages.
 
-    When RawContent is associated with an ComponentVersion, it has some local
+    When Content is associated with an ComponentVersion, it has some local
     key that is unique within the the context of that ComponentVersion. This
     allows the ComponentVersion to do things like store an image file and
     reference it by a "path" key.
 
-    RawContent is immutable and sharable across multiple ComponentVersions and
-    even across LearningPackages.
+    Content is immutable and sharable across multiple ComponentVersions.
     """
 
-    raw_content = models.ForeignKey(RawContent, on_delete=models.RESTRICT)
     component_version = models.ForeignKey(ComponentVersion, on_delete=models.CASCADE)
+    content = models.ForeignKey(Content, on_delete=models.RESTRICT)
 
     uuid = immutable_uuid_field()
-    key = key_field()
+
+    # "key" is a reserved word for MySQL, so we're temporarily using the column
+    # name of "_key" to avoid breaking downstream tooling. A possible
+    # alternative name for this would be "path", since it's most often used as
+    # an internal file path. However, we might also want to put special
+    # identifiers that don't map as cleanly to file paths at some point.
+    key = key_field(db_column="_key")
 
     # Long explanation for the ``learner_downloadable`` field:
     #
-    # Is this RawContent downloadable during the learning experience? This is
+    # Is this Content downloadable during the learning experience? This is
     # NOT about public vs. private permissions on course assets, as that will be
     # a policy that can be changed independently of new versions of the content.
     # For instance, a course team could decide to flip their course assets from
@@ -282,16 +289,16 @@ class ComponentVersionRawContent(models.Model):
             # with two different identifiers, that is permitted.
             models.UniqueConstraint(
                 fields=["component_version", "key"],
-                name="oel_cvrawcontent_uniq_cv_key",
+                name="oel_cvcontent_uniq_cv_key",
             ),
         ]
         indexes = [
             models.Index(
-                fields=["raw_content", "component_version"],
-                name="oel_cvrawcontent_c_cv",
+                fields=["content", "component_version"],
+                name="oel_cvcontent_c_cv",
             ),
             models.Index(
-                fields=["component_version", "raw_content"],
-                name="oel_cvrawcontent_cv_d",
+                fields=["component_version", "content"],
+                name="oel_cvcontent_cv_d",
             ),
         ]

openedx_learning/core/contents/admin.py

@@ -6,13 +6,13 @@ from django.utils.html import format_html
 
 from openedx_learning.lib.admin_utils import ReadOnlyModelAdmin
 
-from .models import RawContent
+from .models import Content
 
 
-@admin.register(RawContent)
-class RawContentAdmin(ReadOnlyModelAdmin):
+@admin.register(Content)
+class ContentAdmin(ReadOnlyModelAdmin):
     """
-    Django admin for RawContent model
+    Django admin for Content model
     """
     list_display = [
         "hash_digest",
@@ -21,6 +21,7 @@ class RawContentAdmin(ReadOnlyModelAdmin):
         "media_type",
         "size",
         "created",
+        "has_file",
     ]
     fields = [
         "learning_package",
@@ -30,30 +31,22 @@ class RawContentAdmin(ReadOnlyModelAdmin):
         "created",
         "file_link",
         "text_preview",
-    ]
-    readonly_fields = [
-        "learning_package",
-        "hash_digest",
-        "media_type",
-        "size",
-        "created",
-        "file_link",
-        "text_preview",
+        "has_file",
     ]
     list_filter = ("media_type", "learning_package")
     search_fields = ("hash_digest",)
 
-    def file_link(self, raw_content):
+    def file_link(self, content: Content):
+        if not content.has_file:
+            return ""
+
         return format_html(
             '<a href="{}">Download</a>',
-            raw_content.file.url,
+            content.file_url(),
         )
 
-    def text_preview(self, raw_content):
-        if not hasattr(raw_content, "text_content"):
-            return "(not available)"
-
+    def text_preview(self, content: Content):
         return format_html(
             '<pre style="white-space: pre-wrap;">\n{}\n</pre>',
-            raw_content.text_content.text,
+            content.text,
         )