From 958b903df8fd5767b3ccdee04a4cda2adeec4ba2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Thu, 17 Apr 2025 14:29:26 +0300
Subject: [PATCH 01/26] feat: create import client

---
 .../import_from_modulestore/helpers.py        | 385 ++++++++++++++++++
 1 file changed, 385 insertions(+)
 create mode 100644 cms/djangoapps/import_from_modulestore/helpers.py

diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
new file mode 100644
index 000000000000..b432ef20f5d3
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -0,0 +1,385 @@
+"""
+Helper functions for importing course content into a library.
+"""
+from datetime import datetime, timezone
+import logging
+import mimetypes
+import os
+import secrets
+
+from django.db import transaction
+from django.db.utils import IntegrityError
+from lxml import etree
+
+from opaque_keys.edx.keys import UsageKey
+from opaque_keys.edx.locator import CourseLocator, LibraryUsageLocatorV2
+from openedx_learning.api import authoring as authoring_api
+from openedx_learning.api.authoring_models import ContainerVersion
+
+from openedx.core.djangoapps.content_libraries import api
+from openedx.core.djangoapps.content_libraries.api.exceptions import IncompatibleTypesError
+from openedx.core.djangoapps.content_staging import api as content_staging_api
+from xmodule.modulestore.django import modulestore
+
+from .data import CompositionLevel
+from .models import Import, PublishableEntityMapping, PublishableEntityImport
+
+
+log = logging.getLogger(__name__)
+parser = etree.XMLParser(strip_cdata=False)
+
+
+class ImportClient:
+    """
+    Client for importing course content into a library.
+
+    This class handles the import of course content from staged content into a
+    content library, creating the appropriate container hierarchy based on the
+    specified composition level.
+    """
+
+    CONTAINER_CREATORS_MAP = {
+        'chapter': authoring_api.create_unit_and_version,  # TODO: replace with create_module_and_version
+        'sequential': authoring_api.create_unit_and_version,  # TODO: replace with create_section_and_version
+        'vertical': authoring_api.create_unit_and_version,
+    }
+
+    CONTAINER_OVERRIDERS_MAP = {
+        'chapter': authoring_api.create_next_unit_version,  # TODO: replace with create_next_module_version
+        'sequential': authoring_api.create_next_unit_version,  # TODO: replace with create_next_section_version
+        'vertical': authoring_api.create_next_unit_version,
+    }
+
+    def __init__(
+        self,
+        import_event: Import,
+        block_usage_key_to_import: str,
+        staged_content: 'StagedContent',
+        composition_level: str,
+        override: bool = False,
+    ):
+        self.import_event = import_event
+        self.block_usage_key_to_import = block_usage_key_to_import
+        self.staged_content = staged_content
+        self.composition_level = composition_level
+        self.override = override
+
+        self.user_id = import_event.user_id
+        self.content_library = import_event.target.contentlibrary
+        self.library_key = self.content_library.library_key
+        self.parser = etree.XMLParser(strip_cdata=False)
+
+    def import_from_staged_content(self):
+        """
+        Import staged content into a library.
+        """
+        node = etree.fromstring(self.staged_content.olx, parser=parser)
+        usage_key = UsageKey.from_string(self.block_usage_key_to_import)
+        block_to_import = get_block_to_import(node, usage_key)
+        if block_to_import is None:
+            return
+
+        self._process_import(self.block_usage_key_to_import, block_to_import)
+
+    def _process_import(self, usage_id, block_to_import):
+        """
+        Process import of a block from staged content into a library.
+
+        Imports a block and its children into the library based on the
+        composition level. It handles both simple and complicated blocks, creating
+        the necessary container hierarchy.
+        """
+        usage_key = UsageKey.from_string(usage_id)
+        result = []
+
+        if block_to_import.tag not in CompositionLevel.COMPLICATED_LEVELS.value:
+            return self._import_simple_block(block_to_import, usage_key)
+
+        for child in block_to_import.getchildren():
+            child_usage_key_string = get_usage_key_string_from_staged_content(
+                self.staged_content, child.get('url_name')
+            )
+            if not child_usage_key_string:
+                continue
+            result.extend(self._import_child_block(child, child_usage_key_string))
+
+        if self.composition_level in CompositionLevel.FLAT_LEVELS.value:
+            return [component for component in result if not isinstance(component, ContainerVersion)]
+        return result
+
+    def _import_simple_block(self, block_to_import, usage_key) -> list:
+        """
+        Import a simple block into the library.
+
+        Creates a block in the library from the staged content block.
+        It returns a list containing the created component version.
+        """
+        component_version = self._create_block_in_library(block_to_import, usage_key)
+        return [component_version] if component_version else []
+
+    def _import_child_block(self, child, child_usage_id):
+        """
+        Import a child block into the library.
+
+        Determines whether the child block is simple or complicated and
+        delegates the import process to the appropriate helper method.
+        """
+        child_usage_key = UsageKey.from_string(child_usage_id)
+        if child.tag in CompositionLevel.COMPLICATED_LEVELS.value:
+            return self._import_complicated_child(child, child_usage_id)
+        else:
+            return self._import_simple_block(child, child_usage_key)
+
+    def _import_complicated_child(self, child, child_usage_id):
+        """
+        Import a complicated child block into the library.
+
+        Handles the import of complicated child blocks, including creating
+        containers and updating components.
+        Returns a list containing the created container version.
+        """
+        if self.composition_level in CompositionLevel.FLAT_LEVELS.value:
+            return self._process_import(child_usage_id, child)
+
+        container_version = self.get_or_create_container(
+            child.tag,
+            child.get('url_name'),
+            child.get('display_name', child.tag)
+        )
+        child_component_versions = self._process_import(child_usage_id, child)
+        self._update_container_components(container_version, child_component_versions)
+        return [container_version]
+
+    def get_or_create_container(self, container_type, key, display_name):
+        """
+        Create a container of the specified type.
+
+        Creates a container (e.g., chapter, sequential, vertical) in the
+        content library.
+        """
+        container_creator_func = self.CONTAINER_CREATORS_MAP.get(container_type)
+        container_override_func = self.CONTAINER_OVERRIDERS_MAP.get(container_type)
+        if not all((container_creator_func, container_override_func)):
+            raise ValueError(f"Unknown container type: {container_type}")
+
+        container_version = self.content_library.learning_package.publishable_entities.filter(key=key).first()
+        if container_version and self.override:
+            container_version = container_override_func(
+                container_version.container,
+                title=display_name or f"New {container_type}",
+                components=[],
+                created=datetime.now(tz=timezone.utc),
+                created_by=self.import_event.user_id,
+            )
+        elif not container_version:
+            _, container_version = container_creator_func(
+                self.import_event.target_id,
+                key=key or secrets.token_hex(16),
+                title=display_name or f"New {container_type}",
+                components=[],
+                created=datetime.now(tz=timezone.utc),
+                created_by=self.import_event.user_id,
+            )
+
+        return container_version
+
+    def _update_container_components(self, container_version, component_versions):
+        """
+        Update components of a container.
+        """
+        return authoring_api.create_next_container_version(
+            container_pk=container_version.container.pk,
+            title=container_version.title,
+            publishable_entities_pks=[
+                cv.container.pk if isinstance(cv, ContainerVersion) else cv.component.pk for cv in component_versions
+            ],
+            entity_version_pks=[cv.pk for cv in component_versions],
+            created=datetime.now(tz=timezone.utc),
+            created_by=self.import_event.user_id,
+            container_version_cls=container_version.__class__,
+        )
+
+    def _create_block_in_library(self, block_to_import, usage_key):
+        """
+        Create a block in a library from a staged content block.
+        """
+        now = datetime.now(tz=timezone.utc)
+        staged_content_files = content_staging_api.get_staged_content_static_files(self.staged_content.id)
+
+        with transaction.atomic():
+            component_type = authoring_api.get_or_create_component_type("xblock.v1", usage_key.block_type)
+            does_component_exist = authoring_api.get_components(
+                self.import_event.target_id
+            ).filter(local_key=usage_key.block_id).exists()
+
+            if does_component_exist:
+                if not self.override:
+                    log.info(f"Component {usage_key.block_id} already exists in library {self.library_key}, skipping.")
+                    return
+                else:
+                    component_version = self._handle_component_override(usage_key, etree.tostring(block_to_import))
+            else:
+                try:
+                    _, library_usage_key = api.validate_can_add_block_to_library(
+                        self.library_key,
+                        block_to_import.tag,
+                        usage_key.block_id,
+                    )
+                except api.IncompatibleTypesError as e:
+                    log.error(f"Error validating block {usage_key} for library {self.library_key}: {e}")
+                    return
+
+                authoring_api.create_component(
+                    self.import_event.target_id,
+                    component_type=component_type,
+                    local_key=usage_key.block_id,
+                    created=now,
+                    created_by=self.import_event.user_id,
+                )
+                component_version = api.set_library_block_olx(library_usage_key, etree.tostring(block_to_import))
+
+            self._process_staged_content_files(
+                component_version,
+                staged_content_files,
+                usage_key,
+                block_to_import,
+                now,
+            )
+            _create_publishable_entity_import(self.import_event, usage_key, component_version)
+
+            return component_version
+
+    def _handle_component_override(self, usage_key, new_content):
+        """
+        Create new ComponentVersion for overridden component.
+        """
+        component_version = None
+        component = self.import_event.target.component_set.filter(local_key=usage_key.block_id).first()
+
+        if component:
+            library_usage_key = LibraryUsageLocatorV2(  # type: ignore[abstract]
+                lib_key=self.library_key,
+                block_type=component.component_type.name,
+                usage_id=component.local_key,
+            )
+            component_version = api.set_library_block_olx(library_usage_key, new_content)
+
+        return component_version
+
+    def _process_staged_content_files(
+        self,
+        component_version,
+        staged_content_files,
+        usage_key,
+        block_to_import,
+        created_at,
+    ):
+        """
+        Process staged content files for a component.
+
+        Processes the staged content files for a component, creating the
+        necessary file content and associating it with the component version.
+        """
+        block_olx = etree.tostring(block_to_import).decode('utf-8')
+
+        for staged_content_file_data in staged_content_files:
+            original_filename = staged_content_file_data.filename
+            file_basename = os.path.basename(original_filename)
+            file_basename_no_ext, _ = os.path.splitext(file_basename)
+
+            # Skip files not referenced in the block
+            if file_basename not in block_olx and file_basename_no_ext not in block_olx:
+                log.info(f"Skipping file {original_filename} as it is not referenced in block {usage_key}")
+                continue
+
+            file_data = content_staging_api.get_staged_content_static_file_data(
+                self.staged_content.id,
+                original_filename,
+            )
+            if not file_data:
+                log.error(
+                    f"Staged content {self.staged_content.id} included referenced "
+                    f"file {original_filename}, but no file data was found."
+                )
+                continue
+
+            filename = f"static/{file_basename}"
+            media_type_str, _ = mimetypes.guess_type(filename)
+            if not media_type_str:
+                media_type_str = "application/octet-stream"
+
+            media_type = authoring_api.get_or_create_media_type(media_type_str)
+            content = authoring_api.get_or_create_file_content(
+                self.import_event.target_id,
+                media_type.id,
+                data=file_data,
+                created=created_at,
+            )
+
+            try:
+                authoring_api.create_component_version_content(component_version.pk, content.id, key=filename)
+            except IntegrityError:
+                pass  # Content already exists
+
+
+def _create_publishable_entity_import(import_event, usage_key, component_version) -> PublishableEntityImport:
+    """
+    Creates relations between the imported component and source usage key and import event.
+    """
+    publishable_entity_mapping, _ = _get_or_create_publishable_entity_mapping(
+        usage_key,
+        component_version.component
+    )
+    return PublishableEntityImport.objects.create(
+        import_event=import_event,
+        result=publishable_entity_mapping,
+        resulting_draft=component_version.publishable_entity_version,
+    )
+
+
+def _get_or_create_publishable_entity_mapping(usage_key, component) -> tuple[PublishableEntityMapping, bool]:
+    """
+    Creates a mapping between the source usage key and the target publishable entity.
+    """
+    return PublishableEntityMapping.objects.get_or_create(
+        source_usage_key=usage_key,
+        target_entity=component.publishable_entity,
+        target_package=component.learning_package
+    )
+
+
+def get_usage_key_string_from_staged_content(staged_content, block_id):
+    """
+    Get the usage ID from a staged content by block ID.
+    """
+    return next((block_usage_id for block_usage_id in staged_content.tags if block_usage_id.endswith(block_id)), None)
+
+
+def get_block_to_import(node, usage_key):
+    """
+    Get the block to import from a node.
+    """
+
+    if node.get('url_name') == usage_key.block_id:
+        return node
+
+    for child in node.getchildren():
+        found = get_block_to_import(child, usage_key)
+        if found is not None:
+            return found
+
+
+def get_items_to_import(import_event):
+    """
+    Collect items to import from a course.
+    """
+    items_to_import = []
+    if isinstance(import_event.source_key, CourseLocator):
+        items_to_import.extend(
+            modulestore().get_items(import_event.source_key, qualifiers={"category": "chapter"}) or []
+        )
+        items_to_import.extend(
+            modulestore().get_items(import_event.source_key, qualifiers={"category": "static_tab"}) or []
+        )
+
+    return items_to_import

From 4213966dfe9d12bbcba686e5bc9078ade60d8c5b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Thu, 17 Apr 2025 14:47:10 +0300
Subject: [PATCH 02/26] feat: create celery tasks for import functionality

---
 .../import_from_modulestore/constants.py      |  5 ++
 .../import_from_modulestore/tasks.py          | 89 +++++++++++++++++++
 .../import_from_modulestore/validators.py     | 31 +++++++
 .../core/djangoapps/content_staging/api.py    | 24 ++---
 4 files changed, 138 insertions(+), 11 deletions(-)
 create mode 100644 cms/djangoapps/import_from_modulestore/constants.py
 create mode 100644 cms/djangoapps/import_from_modulestore/tasks.py
 create mode 100644 cms/djangoapps/import_from_modulestore/validators.py

diff --git a/cms/djangoapps/import_from_modulestore/constants.py b/cms/djangoapps/import_from_modulestore/constants.py
new file mode 100644
index 000000000000..099acfbc2b7b
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/constants.py
@@ -0,0 +1,5 @@
+"""
+Constants for import_from_modulestore app
+"""
+
+IMPORT_FROM_MODULESTORE_PURPOSE = "import_from_modulestore"
diff --git a/cms/djangoapps/import_from_modulestore/tasks.py b/cms/djangoapps/import_from_modulestore/tasks.py
new file mode 100644
index 000000000000..643041c931e4
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/tasks.py
@@ -0,0 +1,89 @@
+"""
+Tasks for course to library import.
+"""
+
+from celery import shared_task
+from celery.utils.log import get_task_logger
+from django.db import transaction
+from edx_django_utils.monitoring import set_code_owner_attribute
+
+from openedx.core.djangoapps.content_staging import api as content_staging_api
+
+from .constants import IMPORT_FROM_MODULESTORE_PURPOSE
+from .data import ImportStatus
+from .helpers import get_items_to_import, ImportClient
+from .models import Import, StagedContentForImport
+from .validators import validate_composition_level
+
+log = get_task_logger(__name__)
+
+
+@shared_task
+@set_code_owner_attribute
+def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
+    """
+    Save courses to staged content task by sections/chapters.
+    """
+    try:
+        import_event = Import.objects.get(uuid=import_uuid)
+    except Import.DoesNotExist:
+        log.info('Import event not found for UUID %s', import_uuid)
+        return
+
+    import_event.clean_related_staged_content()
+    try:
+        with transaction.atomic():
+            items_to_import = get_items_to_import(import_event)
+            for item in items_to_import:
+                staged_content = content_staging_api.stage_xblock_temporarily(
+                    item,
+                    import_event.user.id,
+                    purpose=IMPORT_FROM_MODULESTORE_PURPOSE,
+                )
+                StagedContentForImport.objects.create(
+                    staged_content=staged_content,
+                    import_event=import_event,
+                    source_usage_key=item.location
+                )
+
+            if items_to_import:
+                import_event.set_status(ImportStatus.READY)
+            else:
+                import_event.set_status(ImportStatus.ERROR)
+    except Exception as exc:  # pylint: disable=broad-except
+        import_event.set_status(ImportStatus.ERROR)
+        raise exc
+
+
+@shared_task
+@set_code_owner_attribute
+def import_course_staged_content_to_library_task(
+    usage_keys_string: list[str],
+    import_uuid: str,
+    user_id: int,
+    composition_level: str,
+    override: bool
+) -> None:
+    """
+    Import staged content to a library task.
+    """
+    validate_composition_level(composition_level)
+    try:
+        import_event = Import.objects.get(uuid=import_uuid, status=ImportStatus.READY, user_id=user_id)
+    except Import.DoesNotExist:
+        log.info('Ready import from modulestore not found')
+        return
+
+    with transaction.atomic():
+        for usage_key_string in usage_keys_string:
+            if staged_content_item := import_event.get_staged_content_by_source_usage_key(usage_key_string):  # FIXME
+                import_client = ImportClient(
+                    import_event,
+                    usage_key_string,
+                    staged_content_item,
+                    composition_level,
+                    override,
+                )
+                import_client.import_from_staged_content()
+
+        import_event.set_status(ImportStatus.IMPORTED)
diff --git a/cms/djangoapps/import_from_modulestore/validators.py b/cms/djangoapps/import_from_modulestore/validators.py
new file mode 100644
index 000000000000..c7c7fb79e65d
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/validators.py
@@ -0,0 +1,31 @@
+"""
+Validators for the import_from_modulestore app.
+"""
+from django.utils.translation import gettext_lazy as _
+
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import UsageKey
+
+from .data import CompositionLevel
+
+
+def validate_usage_keys_to_import(usage_keys: list[str | UsageKey]):
+    """
+    Validate the usage keys to import.
+
+    Currently, supports importing from the modulestore only by chapters.
+    """
+    for usage_key in usage_keys:
+        if isinstance(usage_key, str):
+            try:
+                usage_key = UsageKey.from_string(usage_key)
+            except InvalidKeyError:
+                raise ValueError(_(f'Invalid usage key: {usage_key}'))
+        if usage_key.block_type != 'chapter':
+            raise InvalidKeyError(_(f'Importing from modulestore only supports chapters, not {usage_key.block_type}'))
+
+def validate_composition_level(composition_level):
+    if composition_level not in CompositionLevel.values():
+        raise ValueError(
+            _('Invalid composition level: {composition_level}').format(composition_level=composition_level)
+        )
diff --git a/openedx/core/djangoapps/content_staging/api.py b/openedx/core/djangoapps/content_staging/api.py
index 7f8167d9aadd..7baae10baed4 100644
--- a/openedx/core/djangoapps/content_staging/api.py
+++ b/openedx/core/djangoapps/content_staging/api.py
@@ -53,17 +53,19 @@ def _save_xblock_to_staged_content(
 
     expired_ids = []
     with transaction.atomic():
-        # Mark all of the user's existing StagedContent rows as EXPIRED
-        to_expire = _StagedContent.objects.filter(
-            user_id=user_id,
-            purpose=purpose,
-        ).exclude(
-            status=StagedContentStatus.EXPIRED,
-        )
-        for sc in to_expire:
-            expired_ids.append(sc.id)
-            sc.status = StagedContentStatus.EXPIRED
-            sc.save()
+        if purpose == CLIPBOARD_PURPOSE:
+            # Mark all of the user's existing StagedContent rows as EXPIRED
+            to_expire = _StagedContent.objects.filter(
+                user_id=user_id,
+                purpose=purpose,
+            ).exclude(
+                status=StagedContentStatus.EXPIRED,
+            )
+            for sc in to_expire:
+                expired_ids.append(sc.id)
+                sc.status = StagedContentStatus.EXPIRED
+                sc.save()
+
         # Insert a new StagedContent row for this
         staged_content = _StagedContent.objects.create(
             user_id=user_id,

From c03dcd8082439df6a4696f8de4d301fb0fd3199e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Thu, 17 Apr 2025 14:48:23 +0300
Subject: [PATCH 03/26] feat: add python APIs to create and process import

---
 cms/djangoapps/import_from_modulestore/api.py | 43 +++++++++++++++++++
 .../import_from_modulestore/signals.py        | 26 +++++++++++
 2 files changed, 69 insertions(+)
 create mode 100644 cms/djangoapps/import_from_modulestore/api.py
 create mode 100644 cms/djangoapps/import_from_modulestore/signals.py

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
new file mode 100644
index 000000000000..a6adee7ccb35
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -0,0 +1,43 @@
+"""
+API for course to library import.
+"""
+from opaque_keys.edx.keys import LearningContextKey
+
+from .models import Import as _Import
+from .tasks import import_course_staged_content_to_library_task, save_legacy_content_to_staged_content_task
+from .validators import validate_usage_keys_to_import
+
+
+def create_import(source_key: LearningContextKey, user_id: int, learning_package_id: int) -> _Import:
+    """
+    Create a new import event to import a course to a library and save course to staged content.
+    """
+    import_from_modulestore = _Import.objects.create(
+        source_key=source_key,
+        target_id=learning_package_id,
+        user_id=user_id,
+    )
+    save_legacy_content_to_staged_content_task.delay_on_commit(import_from_modulestore.uuid)
+    return import_from_modulestore
+
+
+def import_course_staged_content_to_library(
+    usage_ids: list[str],
+    import_uuid: str,
+    user_id: int,
+    composition_level: str,
+    override: bool
+) -> None:
+    """
+    Import staged content to a library from staged content.
+    """
+    validate_usage_keys_to_import(usage_ids)
+    import_course_staged_content_to_library_task.apply_async(
+        kwargs={
+            'usage_keys_string': usage_ids,
+            'import_uuid': import_uuid,
+            'user_id': user_id,
+            'composition_level': composition_level,
+            'override': override,
+        },
+    )
diff --git a/cms/djangoapps/import_from_modulestore/signals.py b/cms/djangoapps/import_from_modulestore/signals.py
new file mode 100644
index 000000000000..958c7e365f67
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/signals.py
@@ -0,0 +1,26 @@
+"""
+Signals for Import.
+"""
+from django.dispatch import receiver
+from django.db.models.signals import post_save
+
+from .data import ImportStatus
+from .models import Import
+
+
+@receiver(post_save, sender=Import)
+def cancel_incomplete_imports(sender, instance, created, **kwargs):
+    """
+    Cancel any incomplete imports that have the same target as the current import.
+
+    When a new import is created, we want to cancel any other incomplete user imports that have the same target.
+    """
+    if created:
+        incomplete_user_imports_with_same_target = Import.objects.filter(
+            user=instance.user,
+            target=instance.target,
+            source_key=instance.source_key,
+            staged_content_for_import__isnull=False
+        ).exclude(uuid=instance.uuid)
+        for incomplete_import in incomplete_user_imports_with_same_target:
+            incomplete_import.set_status(ImportStatus.CANCELED)

From a3ea142da1fa57512f495605aa0a970d73c3a889 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Thu, 17 Apr 2025 16:22:49 +0300
Subject: [PATCH 04/26] style: fix pylint issues

---
 cms/djangoapps/import_from_modulestore/helpers.py  | 13 ++++++++-----
 .../import_from_modulestore/validators.py          | 14 +++-----------
 2 files changed, 11 insertions(+), 16 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index b432ef20f5d3..f5e749c1df1c 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -17,7 +17,6 @@
 from openedx_learning.api.authoring_models import ContainerVersion
 
 from openedx.core.djangoapps.content_libraries import api
-from openedx.core.djangoapps.content_libraries.api.exceptions import IncompatibleTypesError
 from openedx.core.djangoapps.content_staging import api as content_staging_api
 from xmodule.modulestore.django import modulestore
 
@@ -187,13 +186,17 @@ def _update_container_components(self, container_version, component_versions):
         """
         Update components of a container.
         """
+        entity_rows = [
+            authoring_api.ContainerEntityRow(
+                entity_pk=cv.container.pk if isinstance(cv, ContainerVersion) else cv.component.pk,
+                version_pk=cv.pk,
+            )
+            for cv in component_versions
+        ]
         return authoring_api.create_next_container_version(
             container_pk=container_version.container.pk,
             title=container_version.title,
-            publishable_entities_pks=[
-                cv.container.pk if isinstance(cv, ContainerVersion) else cv.component.pk for cv in component_versions
-            ],
-            entity_version_pks=[cv.pk for cv in component_versions],
+            entity_rows=entity_rows,
             created=datetime.now(tz=timezone.utc),
             created_by=self.import_event.user_id,
             container_version_cls=container_version.__class__,
diff --git a/cms/djangoapps/import_from_modulestore/validators.py b/cms/djangoapps/import_from_modulestore/validators.py
index c7c7fb79e65d..e7d4562c248b 100644
--- a/cms/djangoapps/import_from_modulestore/validators.py
+++ b/cms/djangoapps/import_from_modulestore/validators.py
@@ -1,9 +1,6 @@
 """
 Validators for the import_from_modulestore app.
 """
-from django.utils.translation import gettext_lazy as _
-
-from opaque_keys import InvalidKeyError
 from opaque_keys.edx.keys import UsageKey
 
 from .data import CompositionLevel
@@ -17,15 +14,10 @@ def validate_usage_keys_to_import(usage_keys: list[str | UsageKey]):
     """
     for usage_key in usage_keys:
         if isinstance(usage_key, str):
-            try:
-                usage_key = UsageKey.from_string(usage_key)
-            except InvalidKeyError:
-                raise ValueError(_(f'Invalid usage key: {usage_key}'))
+            usage_key = UsageKey.from_string(usage_key)
         if usage_key.block_type != 'chapter':
-            raise InvalidKeyError(_(f'Importing from modulestore only supports chapters, not {usage_key.block_type}'))
+            raise ValueError(f'Importing from modulestore only supports chapters, not {usage_key.block_type}')
 
 def validate_composition_level(composition_level):
     if composition_level not in CompositionLevel.values():
-        raise ValueError(
-            _('Invalid composition level: {composition_level}').format(composition_level=composition_level)
-        )
+        raise ValueError(f'Invalid composition level: {composition_level}')

From 9acd085be70baeb832eb29aa7fe49e31e2dcab9e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Thu, 17 Apr 2025 17:01:38 +0300
Subject: [PATCH 05/26] test: add tests

---
 .../import_from_modulestore/tests/__init__.py |   0
 .../tests/factories.py                        |  30 ++
 .../import_from_modulestore/tests/test_api.py | 102 +++++
 .../tests/test_helpers.py                     | 370 ++++++++++++++++++
 .../tests/test_tasks.py                       | 165 ++++++++
 .../tests/test_validators.py                  |  31 ++
 .../import_from_modulestore/validators.py     |   1 +
 .../content_libraries/tests/factories.py      |  39 ++
 setup.cfg                                     |   1 +
 9 files changed, 739 insertions(+)
 create mode 100644 cms/djangoapps/import_from_modulestore/tests/__init__.py
 create mode 100644 cms/djangoapps/import_from_modulestore/tests/factories.py
 create mode 100644 cms/djangoapps/import_from_modulestore/tests/test_api.py
 create mode 100644 cms/djangoapps/import_from_modulestore/tests/test_helpers.py
 create mode 100644 cms/djangoapps/import_from_modulestore/tests/test_tasks.py
 create mode 100644 cms/djangoapps/import_from_modulestore/tests/test_validators.py
 create mode 100644 openedx/core/djangoapps/content_libraries/tests/factories.py

diff --git a/cms/djangoapps/import_from_modulestore/tests/__init__.py b/cms/djangoapps/import_from_modulestore/tests/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/cms/djangoapps/import_from_modulestore/tests/factories.py b/cms/djangoapps/import_from_modulestore/tests/factories.py
new file mode 100644
index 000000000000..2207a799ef33
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/tests/factories.py
@@ -0,0 +1,30 @@
+"""
+Factories for Import model.
+"""
+
+import uuid
+
+import factory
+from factory.django import DjangoModelFactory
+from opaque_keys.edx.keys import CourseKey
+
+from common.djangoapps.student.tests.factories import UserFactory
+from cms.djangoapps.import_from_modulestore.models import Import
+from openedx.core.djangoapps.content_libraries.tests import factories
+
+
+class ImportFactory(DjangoModelFactory):
+    """
+    Factory for Import model.
+    """
+
+    class Meta:
+        model = Import
+
+    @factory.lazy_attribute
+    def source_key(self):
+        return CourseKey.from_string(f'course-v1:edX+DemoX+{self.uuid}')
+
+    target = factory.SubFactory(factories.LearningPackageFactory)
+    uuid = factory.LazyFunction(lambda: str(uuid.uuid4()))
+    user = factory.SubFactory(UserFactory)
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_api.py b/cms/djangoapps/import_from_modulestore/tests/test_api.py
new file mode 100644
index 000000000000..5627b8b89e4f
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/tests/test_api.py
@@ -0,0 +1,102 @@
+"""
+Test cases for import_from_modulestore.api module.
+"""
+from unittest.mock import patch
+
+import pytest
+from opaque_keys.edx.keys import CourseKey
+
+from common.djangoapps.student.tests.factories import UserFactory
+from cms.djangoapps.import_from_modulestore.api import create_import, import_course_staged_content_to_library
+from cms.djangoapps.import_from_modulestore.data import ImportStatus
+from cms.djangoapps.import_from_modulestore.models import Import
+from openedx.core.djangoapps.content_libraries.tests import factories
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
+from .factories import ImportFactory
+
+
+@pytest.mark.django_db
+class TestCourseToLibraryImportAPI(ModuleStoreTestCase):
+    """
+    Test cases for Import API.
+    """
+
+    def setUp(self):
+        super().setUp()
+
+        self.library = factories.ContentLibraryFactory()
+
+    def test_create_import(self):
+        """
+        Test create_import function.
+        """
+        course_id = "course-v1:edX+DemoX+Demo_Course"
+        user = UserFactory()
+        create_import(course_id, user.id, self.library.learning_package_id)
+
+        import_event = Import.objects.get()
+        assert import_event.source_key == CourseKey.from_string(course_id)
+        assert import_event.target == self.library.learning_package
+        assert import_event.user_id == user.id
+        assert import_event.status == ImportStatus.PENDING
+
+    def test_import_course_staged_content_to_library(self):
+        """
+        Test import_course_staged_content_to_library function with different override values.
+        """
+        import_event = ImportFactory(
+            target=self.library.learning_package,
+            source_key=CourseKey.from_string("course-v1:edX+DemoX+Demo_Course"),
+        )
+        usage_ids = [
+            "block-v1:edX+DemoX+Demo_Course+type@chapter+block@123",
+            "block-v1:edX+DemoX+Demo_Course+type@chapter+block@456",
+        ]
+        override = False
+
+        with patch(
+            "cms.djangoapps.import_from_modulestore.api.import_course_staged_content_to_library_task"
+        ) as import_course_staged_content_to_library_task_mock:
+            import_course_staged_content_to_library(
+                usage_ids,
+                import_event.uuid,
+                import_event.user.id,
+                "xblock",
+                override
+            )
+
+        import_course_staged_content_to_library_task_mock.apply_async.assert_called_once_with(
+            kwargs={
+                "usage_keys_string": usage_ids,
+                "import_uuid": import_event.uuid,
+                "user_id": import_event.user.id,
+                "composition_level": "xblock",
+                "override": override,
+            },
+        )
+
+    def test_import_course_staged_content_to_library_invalid_usage_key(self):
+        """
+        Test import_course_staged_content_to_library function with not chapter usage keys.
+        """
+        import_event = ImportFactory(
+            target=self.library.learning_package,
+            source_key=CourseKey.from_string("course-v1:edX+DemoX+Demo_Course"),
+        )
+        usage_ids = [
+            "block-v1:edX+DemoX+Demo_Course+type@problem+block@123",
+            "block-v1:edX+DemoX+Demo_Course+type@vertical+block@456",
+        ]
+
+        with patch(
+            "cms.djangoapps.import_from_modulestore.api.import_course_staged_content_to_library_task"
+        ) as import_course_staged_content_to_library_task_mock:
+            with self.assertRaises(ValueError):
+                import_course_staged_content_to_library(
+                    usage_ids,
+                    import_event.uuid,
+                    import_event.user.id,
+                    "xblock",
+                    False
+                )
+        import_course_staged_content_to_library_task_mock.apply_async.assert_not_called()
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
new file mode 100644
index 000000000000..9c0b56d45bbd
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
@@ -0,0 +1,370 @@
+"""
+Tests for the import_from_modulestore helper functions.
+"""
+import ddt
+from organizations.models import Organization
+from unittest import mock
+from unittest.mock import patch
+
+from lxml import etree
+from openedx_learning.api.authoring_models import LearningPackage
+
+from cms.djangoapps.import_from_modulestore import api
+from cms.djangoapps.import_from_modulestore.helpers import ImportClient
+from common.djangoapps.student.tests.factories import UserFactory
+
+from openedx.core.djangoapps.content_libraries import api as content_libraries_api
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory, BlockFactory
+
+
+@ddt.ddt
+class TestImportClient(ModuleStoreTestCase):
+    """
+    Functional tests for the ImportClient class.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.library = content_libraries_api.create_library(
+            org=Organization.objects.create(name='Organization 1', short_name='org1'),
+            slug='lib_1',
+            title='Library Org 1',
+            description='This is a library from Org 1',
+        )
+        self.user = UserFactory()
+        self.course = CourseFactory.create()
+        self.chapter = BlockFactory.create(category='chapter', parent=self.course, display_name='Chapter')
+        self.sequential = BlockFactory.create(category='sequential', parent=self.chapter, display_name='Sequential')
+        self.vertical = BlockFactory.create(category='vertical', parent=self.sequential, display_name='Vertical')
+        self.problem = BlockFactory.create(
+            category='problem',
+            parent=self.vertical,
+            display_name='Problem',
+            data="""<problem url_name="" display_name="DisplayName"><optionresponse></optionresponse></problem>""",
+        )
+        self.video = BlockFactory.create(
+            category='video',
+            parent=self.vertical,
+            display_name='Video',
+            data="""<video youtube="1.00:3_yD_cEKoCk" url_name="SampleProblem"/>""",
+        )
+        with self.captureOnCommitCallbacks(execute=True):
+            self.import_event = api.create_import(
+                source_key=self.course.id,
+                learning_package_id=self.library.learning_package_id,
+                user_id=self.user.id,
+            )
+        self.parser = etree.XMLParser(strip_cdata=False)
+
+    def test_import_from_staged_content(self):
+        expected_imported_xblocks = [self.video, self.problem]
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=str(self.chapter.location),
+            composition_level='xblock',
+            override=False
+        )
+
+        import_client.import_from_staged_content()
+
+        learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
+        self.assertEqual(learning_package.content_set.count(), len(expected_imported_xblocks))
+
+    @patch('cms.djangoapps.import_from_modulestore.helpers.ImportClient._process_import')
+    def test_import_from_staged_content_block_not_found(self, mocked_process_import):
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import='block-v1:edX+Demo+2025+type@chapter+block@12345',
+            composition_level='xblock',
+            override=False
+        )
+
+        import_client.import_from_staged_content()
+
+        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
+        self.assertTrue(not library_learning_package.content_set.count())
+        mocked_process_import.assert_not_called()
+
+    @ddt.data('chapter', 'sequential', 'vertical')
+    def test_create_container(self, block_lvl):
+        container_to_import = getattr(self, block_lvl)
+        block_usage_key_to_import = str(container_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(block_usage_key_to_import)
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='xblock',
+            override=False
+        )
+        import_client.get_or_create_container(
+            container_to_import.category,
+            container_to_import.location.block_id,
+            container_to_import.display_name
+        )
+
+        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
+        self.assertEqual(library_learning_package.publishable_entities.count(), 1)
+
+    def test_create_container_with_xblock(self):
+        block_usage_key_to_import = str(self.problem.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(block_usage_key_to_import)
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='xblock',
+            override=False
+        )
+        with self.assertRaises(ValueError):
+            import_client.get_or_create_container(
+                self.problem.category,
+                self.problem.location.block_id,
+                self.problem.display_name
+            )
+
+    @ddt.data('chapter', 'sequential', 'vertical')
+    def test_process_import_with_complicated_blocks(self, block_lvl):
+        container_to_import = getattr(self, block_lvl)
+        block_usage_key_to_import = str(container_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        expected_imported_xblocks = [self.problem, self.video]
+
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='xblock',
+            override=False
+        )
+        block_to_import = etree.fromstring(staged_content.olx, parser=self.parser)
+        # pylint: disable=protected-access
+        result = import_client._process_import(block_usage_key_to_import, block_to_import)
+
+        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
+        self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
+        self.assertEqual(len(result), len(expected_imported_xblocks))
+        self.assertEqual(self.import_event.publishableentityimport_set.count(), len(expected_imported_xblocks))
+
+    @ddt.data('problem', 'video')
+    def test_process_import_with_simple_blocks(self, block_type_to_import):
+        block_to_import = getattr(self, block_type_to_import)
+        block_usage_key_to_import = str(block_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        expected_imported_xblocks = [block_to_import]
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='xblock',
+            override=False
+        )
+
+        block_to_import = etree.fromstring(block_to_import.data, parser=self.parser)
+        # pylint: disable=protected-access
+        result = import_client._process_import(block_usage_key_to_import, block_to_import)
+
+        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
+        self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
+        self.assertEqual(len(result), len(expected_imported_xblocks))
+        self.assertEqual(self.import_event.publishableentityimport_set.count(), len(expected_imported_xblocks))
+
+    @ddt.data(True, False)
+    def test_process_import_with_override(self, override):
+        block_to_import = self.problem
+        block_usage_key_to_import = str(block_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='xblock',
+            override=False
+        )
+
+        block_xml = etree.fromstring(block_to_import.data, parser=self.parser)
+        # pylint: disable=protected-access
+        result1 = import_client._process_import(block_usage_key_to_import, block_xml)
+        self.assertEqual(len(result1), 1)
+
+        with self.captureOnCommitCallbacks(execute=True):
+            new_import_event = api.create_import(
+                source_key=self.course.id,
+                learning_package_id=self.library.learning_package_id,
+                user_id=self.user.id,
+            )
+        new_staged_content = new_import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        import_client = ImportClient(
+            import_event=new_import_event,
+            staged_content=new_staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='xblock',
+            override=override
+        )
+
+        if override:
+            modified_data = block_to_import.data.replace('DisplayName', 'ModifiedName')
+            modified_block = BlockFactory.create(
+                category='problem',
+                parent=self.vertical,
+                display_name='Modified Problem',
+                data=modified_data,
+            )
+            block_xml = etree.fromstring(modified_block.data, parser=self.parser)
+
+            # pylint: disable=protected-access
+            result2 = import_client._process_import(block_usage_key_to_import, block_xml)
+            self.assertEqual(len(result2), 1)
+            assert result2[0].title == 'ModifiedName'
+        else:
+            # pylint: disable=protected-access
+            result2 = import_client._process_import(block_usage_key_to_import, block_xml)
+            self.assertEqual(result2, [])
+
+    @patch('cms.djangoapps.import_from_modulestore.helpers.authoring_api')
+    def test_container_override(self, mock_authoring_api):
+        container_to_import = self.vertical
+        block_usage_key_to_import = str(container_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='vertical',
+            override=False
+        )
+
+        container_version = import_client.get_or_create_container(
+            'vertical',
+            container_to_import.location.block_id,
+            container_to_import.display_name
+        )
+        assert container_version is not None
+        assert container_version.title == container_to_import.display_name
+
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='vertical',
+            override=True
+        )
+        overrided_container_version = import_client.get_or_create_container(
+            'vertical',
+            container_to_import.location.block_id,
+            'New Display Name'
+        )
+        assert overrided_container_version is not None
+        assert overrided_container_version.title == 'New Display Name'
+
+    @ddt.data('xblock', 'vertical')
+    def test_composition_levels(self, composition_level):
+        expected_imported_blocks = [self.problem, self.video] if composition_level == 'xblock' else [self.vertical]
+
+        container_to_import = self.vertical
+        block_usage_key_to_import = str(container_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level=composition_level,
+            override=False
+        )
+
+        block_xml = etree.fromstring(staged_content.olx, parser=self.parser)
+        # pylint: disable=protected-access
+        result = import_client._process_import(block_usage_key_to_import, block_xml)
+
+        self.assertEqual(len(result), len(expected_imported_blocks))
+
+    @patch('cms.djangoapps.import_from_modulestore.helpers.content_staging_api')
+    def test_process_staged_content_files(self, mock_content_staging_api):
+        block_to_import = self.problem
+        block_usage_key_to_import = str(block_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='xblock',
+            override=False
+        )
+
+        mock_file_data = b'file content'
+        mock_file = mock.MagicMock()
+        mock_file.filename = 'test.png'
+        mock_content_staging_api.get_staged_content_static_files.return_value = [mock_file]
+        mock_content_staging_api.get_staged_content_static_file_data.return_value = mock_file_data
+
+        modified_data = '<problem url_name="" display_name="ProblemWithImage"><img src="test.png"/></problem>'
+        modified_block = BlockFactory.create(
+            category='problem',
+            parent=self.vertical,
+            display_name='Problem With Image',
+            data=modified_data,
+        )
+
+        with patch('cms.djangoapps.import_from_modulestore.helpers.authoring_api') as mock_authoring_api:
+            mock_component_type = mock.MagicMock()
+            mock_component_version = mock.MagicMock()
+            mock_media_type = mock.MagicMock()
+            mock_file_content = mock.MagicMock()
+
+            mock_authoring_api.get_or_create_component_type.return_value = mock_component_type
+            mock_authoring_api.get_components.return_value.filter.return_value.exists.return_value = False
+            mock_authoring_api.get_or_create_media_type.return_value = mock_media_type
+            mock_authoring_api.get_or_create_file_content.return_value = mock_file_content
+
+            with patch('cms.djangoapps.import_from_modulestore.helpers.api') as mock_api:
+                mock_api.validate_can_add_block_to_library.return_value = (None, None)
+                mock_api.set_library_block_olx.return_value = mock_component_version
+
+                with patch('cms.djangoapps.import_from_modulestore.helpers._create_publishable_entity_import'):
+                    block_xml = etree.fromstring(modified_data, parser=self.parser)
+
+                    # pylint: disable=protected-access
+                    import_client._create_block_in_library(block_xml, modified_block.location)
+
+                    mock_content_staging_api.get_staged_content_static_file_data.assert_called_once_with(
+                        staged_content.id, 'test.png'
+                    )
+                    mock_authoring_api.get_or_create_file_content.assert_called_once()
+                    mock_authoring_api.create_component_version_content.assert_called_once()
+
+    def test_update_container_components(self):
+        container_to_import = self.vertical
+        block_usage_key_to_import = str(container_to_import.location)
+        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+
+        import_client = ImportClient(
+            import_event=self.import_event,
+            staged_content=staged_content,
+            block_usage_key_to_import=block_usage_key_to_import,
+            composition_level='container',
+            override=False
+        )
+
+        with patch('cms.djangoapps.import_from_modulestore.helpers.authoring_api') as mock_authoring_api:
+            mock_container_version = mock.MagicMock()
+            mock_component_version1 = mock.MagicMock()
+            mock_component_version2 = mock.MagicMock()
+            mock_component_versions = [mock_component_version1, mock_component_version2]
+
+            # pylint: disable=protected-access
+            import_client._update_container_components(mock_container_version, mock_component_versions)
+
+            mock_authoring_api.create_next_container_version.assert_called_once()
+            call_args = mock_authoring_api.create_next_container_version.call_args[1]
+            self.assertEqual(call_args['container_pk'], mock_container_version.container.pk)
+            self.assertEqual(call_args['title'], mock_container_version.title)
+            self.assertEqual(call_args['created_by'], self.user.id)
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
new file mode 100644
index 000000000000..1e7123bec51d
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
@@ -0,0 +1,165 @@
+"""
+Tests for tasks in import_from_modulestore app.
+"""
+from organizations.models import Organization
+from openedx_learning.api.authoring_models import LearningPackage
+from unittest.mock import patch
+
+from cms.djangoapps.import_from_modulestore.data import ImportStatus
+from cms.djangoapps.import_from_modulestore.tasks import (
+    import_course_staged_content_to_library_task,
+    save_legacy_content_to_staged_content_task,
+)
+from openedx.core.djangoapps.content_libraries import api as content_libraries_api
+from openedx.core.djangoapps.content_libraries.api import ContentLibrary
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import CourseFactory, BlockFactory
+
+from .factories import ImportFactory
+
+
+class ImportCourseToLibraryMixin(ModuleStoreTestCase):
+    """
+    Mixin for setting up data for tests.
+    """
+
+    def setUp(self):
+        super().setUp()
+
+        self.library = content_libraries_api.create_library(
+            org=Organization.objects.create(name='Organization 1', short_name='org1'),
+            slug='lib_1',
+            title='Library Org 1',
+            description='This is a library from Org 1',
+        )
+        self.content_library = ContentLibrary.objects.get_by_key(self.library.key)
+
+        self.course = CourseFactory.create()
+        self.chapter = BlockFactory.create(category='chapter', parent=self.course, display_name='Chapter 1')
+        self.sequential = BlockFactory.create(category='sequential', parent=self.chapter, display_name='Sequential 1')
+        self.vertical = BlockFactory.create(category='vertical', parent=self.sequential, display_name='Vertical 1')
+        self.video = BlockFactory.create(category='video', parent=self.vertical, display_name='Video 1')
+        self.problem = BlockFactory.create(category='problem', parent=self.vertical, display_name='Problem 1')
+
+        # self.course2 = CourseFactory.create()
+        # self.chapter2 = BlockFactory.create(category='chapter', parent=self.course, display_name='Chapter 2')
+        self.chapter2 = BlockFactory.create(category='chapter', parent=self.course, display_name='Chapter 2')
+        self.sequential2 = BlockFactory.create(category='sequential', parent=self.chapter2, display_name='Sequential 2')
+        self.vertical2 = BlockFactory.create(category='vertical', parent=self.sequential2, display_name='Vertical 2')
+        self.video2 = BlockFactory.create(category='video', parent=self.vertical2, display_name='Video 2')
+        self.problem2 = BlockFactory.create(category='problem', parent=self.vertical2, display_name='Problem 2')
+
+        self.import_event = ImportFactory(
+            source_key=self.course.id,
+            target=self.content_library.learning_package,
+        )
+        self.user = self.import_event.user
+
+
+class TestSaveCourseSectionsToStagedContentTask(ImportCourseToLibraryMixin):
+    """
+    Test cases for save_course_sections_to_staged_content_task.
+    """
+
+    def test_save_legacy_content_to_staged_content_task(self):
+        """
+        End-to-end test for save_legacy_content_to_staged_content_task.
+        """
+        course_chapters_to_import = [self.chapter, self.chapter2]
+        save_legacy_content_to_staged_content_task(self.import_event.uuid)
+
+        self.import_event.refresh_from_db()
+        self.assertEqual(self.import_event.staged_content_for_import.count(), len(course_chapters_to_import))
+        self.assertEqual(self.import_event.status, ImportStatus.READY)
+
+    def test_old_staged_content_deletion_before_save_new(self):
+        """ Checking that repeated saving of the same content does not create duplicates. """
+        course_chapters_to_import = [self.chapter, self.chapter2]
+
+        save_legacy_content_to_staged_content_task(self.import_event.uuid)
+
+        self.assertEqual(self.import_event.staged_content_for_import.count(), len(course_chapters_to_import))
+
+        save_legacy_content_to_staged_content_task(self.import_event.uuid)
+
+        self.assertEqual(self.import_event.staged_content_for_import.count(), len(course_chapters_to_import))
+
+
+class TestImportLibraryFromStagedContentTask(ImportCourseToLibraryMixin):
+    """
+    Test cases for import_course_staged_content_to_library_task.
+    """
+
+    def _is_imported(self, library, xblock):
+        library_learning_package = LearningPackage.objects.get(id=library.learning_package_id)
+        self.assertTrue(library_learning_package.content_set.filter(text__icontains=xblock.display_name).exists())
+
+    def test_import_course_staged_content_to_library_task(self):
+        """ End-to-end test for import_course_staged_content_to_library_task. """
+        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
+        self.assertEqual(library_learning_package.content_set.count(), 0)
+        expected_imported_xblocks = [self.problem, self.problem2, self.video, self.video2]
+        save_legacy_content_to_staged_content_task(self.import_event.uuid)
+
+        import_course_staged_content_to_library_task(
+            [str(self.chapter.location), str(self.chapter2.location)],
+            self.import_event.uuid,
+            self.user.id,
+            'xblock',
+            override=True
+        )
+
+        self.import_event.refresh_from_db()
+        self.assertEqual(self.import_event.status, ImportStatus.IMPORTED)
+
+        for xblock in expected_imported_xblocks:
+            self._is_imported(self.library, xblock)
+
+        library_learning_package.refresh_from_db()
+        self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
+
+    @patch('cms.djangoapps.import_from_modulestore.tasks.ImportClient')
+    def test_import_library_block_not_found(self, mock_import_client):
+        """ Test that if a block is not found in the staged content, it is not imported. """
+        non_existent_usage_ids = ['block-v1:edX+Demo+2023+type@vertical+block@12345']
+        save_legacy_content_to_staged_content_task(self.import_event.uuid)
+
+        import_course_staged_content_to_library_task(
+            non_existent_usage_ids,
+            str(self.import_event.uuid),
+            self.user.id,
+            'xblock',
+            override=True,
+        )
+        mock_import_client.assert_not_called()
+
+    def test_cannot_import_staged_content_twice(self):
+        """
+        Tests if after importing staged content into the library,
+        the staged content is deleted and cannot be imported again.
+        """
+        chapters_to_import = [self.chapter, self.chapter2]
+        expected_imported_xblocks = [self.problem, self.video]
+        save_legacy_content_to_staged_content_task(self.import_event.uuid)
+
+        self.import_event.refresh_from_db()
+        self.assertEqual(self.import_event.staged_content_for_import.count(), len(chapters_to_import))
+        self.assertEqual(self.import_event.status, ImportStatus.READY)
+
+        import_course_staged_content_to_library_task(
+            [str(self.chapter.location)],
+            str(self.import_event.uuid),
+            self.user.id,
+            'xblock',
+            override=True,
+        )
+
+        for xblock in expected_imported_xblocks:
+            self._is_imported(self.library, xblock)
+
+        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
+        self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
+
+        self.import_event.refresh_from_db()
+        self.assertEqual(self.import_event.status, ImportStatus.IMPORTED)
+        self.assertTrue(not self.import_event.staged_content_for_import.exists())
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_validators.py b/cms/djangoapps/import_from_modulestore/tests/test_validators.py
new file mode 100644
index 000000000000..961d1cc81ba7
--- /dev/null
+++ b/cms/djangoapps/import_from_modulestore/tests/test_validators.py
@@ -0,0 +1,31 @@
+"""
+Tests for import_from_modulestore validators
+"""
+
+from typing import get_args
+
+from django.test import TestCase
+import pytest
+
+from cms.djangoapps.import_from_modulestore.validators import (
+    validate_composition_level,
+)
+from cms.djangoapps.import_from_modulestore.data import CompositionLevel
+
+
+class TestValidateCompositionLevel(TestCase):
+    """
+    Test cases for validate_composition_level function.
+    Case 1: Valid composition level
+    Case 2: Invalid composition level
+    """
+
+    def test_valid_composition_level(self):
+        for level in get_args(CompositionLevel):
+            # Should not raise an exception for valid levels
+            validate_composition_level(level)
+
+    def test_invalid_composition_level(self):
+        with pytest.raises(ValueError) as exc:
+            validate_composition_level('invalid_composition_level')
+        assert 'Invalid composition level: invalid_composition_level' in str(exc.value)
diff --git a/cms/djangoapps/import_from_modulestore/validators.py b/cms/djangoapps/import_from_modulestore/validators.py
index e7d4562c248b..4c9308bb7bdc 100644
--- a/cms/djangoapps/import_from_modulestore/validators.py
+++ b/cms/djangoapps/import_from_modulestore/validators.py
@@ -18,6 +18,7 @@ def validate_usage_keys_to_import(usage_keys: list[str | UsageKey]):
         if usage_key.block_type != 'chapter':
             raise ValueError(f'Importing from modulestore only supports chapters, not {usage_key.block_type}')
 
+
 def validate_composition_level(composition_level):
     if composition_level not in CompositionLevel.values():
         raise ValueError(f'Invalid composition level: {composition_level}')
diff --git a/openedx/core/djangoapps/content_libraries/tests/factories.py b/openedx/core/djangoapps/content_libraries/tests/factories.py
new file mode 100644
index 000000000000..5914370a409a
--- /dev/null
+++ b/openedx/core/djangoapps/content_libraries/tests/factories.py
@@ -0,0 +1,39 @@
+"""
+Factories for content_libraries models.
+"""
+import factory
+import uuid
+from factory.django import DjangoModelFactory
+from organizations.tests.factories import OrganizationFactory
+
+from openedx_learning.api.authoring_models import LearningPackage
+from openedx.core.djangoapps.content_libraries.api import ContentLibrary
+
+
+class LearningPackageFactory(DjangoModelFactory):
+    """
+    Factory for LearningPackage model.
+    """
+
+    class Meta:
+        model = LearningPackage
+
+    title = factory.Faker('sentence')
+    description = factory.Faker('sentence')
+    uuid = factory.LazyFunction(lambda: str(uuid.uuid4()))
+    created = factory.Faker('date_time')
+    updated = factory.Faker('date_time')
+
+
+class ContentLibraryFactory(DjangoModelFactory):
+    """
+    Factory for ContentLibrary model.
+    """
+
+    class Meta:
+        model = ContentLibrary
+
+    org = factory.SubFactory(OrganizationFactory)
+    license = factory.Faker('sentence')
+    slug = factory.Faker('slug')
+    learning_package = factory.SubFactory(LearningPackageFactory)
diff --git a/setup.cfg b/setup.cfg
index d83ae7d2765e..e30f66da9c16 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -183,6 +183,7 @@ allowed_modules =
     # See https://open-edx-proposals.readthedocs.io/en/latest/best-practices/oep-0049-django-app-patterns.html#api-py
     api
     data
+    tests.factories
 
 [importlinter:contract:3]
 name = Do not import apps from openedx-learning (only import from openedx_learning.api.* and openedx_learning.lib.*).

From ff2903deaf3d3682d996416c844d6b7c9216b973 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Thu, 17 Apr 2025 22:09:44 +0300
Subject: [PATCH 06/26] refactor: fix after rebase

---
 cms/djangoapps/import_from_modulestore/api.py |  2 +-
 .../import_from_modulestore/data.py           | 25 +++++++++++++++++++
 .../import_from_modulestore/models.py         |  9 ++++++-
 .../tests/factories.py                        |  2 +-
 4 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
index a6adee7ccb35..860c8c73d139 100644
--- a/cms/djangoapps/import_from_modulestore/api.py
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -14,7 +14,7 @@ def create_import(source_key: LearningContextKey, user_id: int, learning_package
     """
     import_from_modulestore = _Import.objects.create(
         source_key=source_key,
-        target_id=learning_package_id,
+        target_change_id=learning_package_id,
         user_id=user_id,
     )
     save_legacy_content_to_staged_content_task.delay_on_commit(import_from_modulestore.uuid)
diff --git a/cms/djangoapps/import_from_modulestore/data.py b/cms/djangoapps/import_from_modulestore/data.py
index 7821e463a76a..0b0ff813cac6 100644
--- a/cms/djangoapps/import_from_modulestore/data.py
+++ b/cms/djangoapps/import_from_modulestore/data.py
@@ -1,6 +1,8 @@
 """
 This module contains the data models for the import_from_modulestore app.
 """
+from enum import Enum
+
 from django.db.models import TextChoices
 from django.utils.translation import gettext_lazy as _
 
@@ -18,3 +20,26 @@ class ImportStatus(TextChoices):
     IMPORTING_FAILED = 'importing_failed', _('Failed to import staged content')
     IMPORTED = 'imported', _('Successfully imported content')
     CANCELED = 'canceled', _('Canceled')
+
+class CompositionLevel(Enum):
+    """
+    Enumeration of composition levels for course content.
+    Defines the different levels of composition for course content,
+    including chapters, sequentials, verticals, and xblocks.
+    It also categorizes these levels into complicated and flat
+    levels for easier processing.
+    """
+
+    CHAPTER = 'chapter'
+    SEQUENTIAL = 'sequential'
+    VERTICAL = 'vertical'
+    XBLOCK = 'xblock'
+    COMPLICATED_LEVELS = [CHAPTER, SEQUENTIAL, VERTICAL]
+    FLAT_LEVELS = [XBLOCK]
+
+    @classmethod
+    def values(cls):
+        """
+        Returns all levels of composition levels.
+        """
+        return [composition_level.value for composition_level in cls]
diff --git a/cms/djangoapps/import_from_modulestore/models.py b/cms/djangoapps/import_from_modulestore/models.py
index acbe82fa6d07..8fd9e46584fe 100644
--- a/cms/djangoapps/import_from_modulestore/models.py
+++ b/cms/djangoapps/import_from_modulestore/models.py
@@ -1,7 +1,7 @@
 """
 Models for the course to library import app.
 """
-
+from typing import Optional
 import uuid as uuid_tools
 
 from django.contrib.auth import get_user_model
@@ -62,6 +62,13 @@ def clean_related_staged_content(self) -> None:
         for staged_content_for_import in self.staged_content_for_import.all():
             staged_content_for_import.staged_content.delete()
 
+    def get_staged_content_by_source_usage_key(self, source_key) -> Optional["StagedContent"]:
+        """
+        Get staged content by source usage key in related to import staged content.
+        """
+        staged_content_for_import = self.staged_content_for_import.filter(source_usage_key=source_key).first()
+        return staged_content_for_import.staged_content if staged_content_for_import else None
+
 
 class PublishableEntityMapping(TimeStampedModel):
     """
diff --git a/cms/djangoapps/import_from_modulestore/tests/factories.py b/cms/djangoapps/import_from_modulestore/tests/factories.py
index 2207a799ef33..fabb99af2163 100644
--- a/cms/djangoapps/import_from_modulestore/tests/factories.py
+++ b/cms/djangoapps/import_from_modulestore/tests/factories.py
@@ -25,6 +25,6 @@ class Meta:
     def source_key(self):
         return CourseKey.from_string(f'course-v1:edX+DemoX+{self.uuid}')
 
-    target = factory.SubFactory(factories.LearningPackageFactory)
+    target_change = factory.SubFactory(factories.LearningPackageFactory)
     uuid = factory.LazyFunction(lambda: str(uuid.uuid4()))
     user = factory.SubFactory(UserFactory)

From cbfe82dd0a0002c7dca3d8a74c918afcf03f10cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Fri, 18 Apr 2025 19:00:15 +0300
Subject: [PATCH 07/26] refactor: fix after changed relations in the import
 models

---
 cms/djangoapps/import_from_modulestore/api.py |   8 +-
 .../import_from_modulestore/data.py           |   5 +
 .../import_from_modulestore/helpers.py        | 148 +++++++++++-------
 .../import_from_modulestore/signals.py        |   2 +-
 .../import_from_modulestore/tasks.py          |  57 ++++---
 5 files changed, 138 insertions(+), 82 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
index 860c8c73d139..8e12726d385f 100644
--- a/cms/djangoapps/import_from_modulestore/api.py
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -2,19 +2,19 @@
 API for course to library import.
 """
 from opaque_keys.edx.keys import LearningContextKey
+from openedx_learning.api import authoring as authoring_api
 
 from .models import Import as _Import
 from .tasks import import_course_staged_content_to_library_task, save_legacy_content_to_staged_content_task
 from .validators import validate_usage_keys_to_import
 
 
-def create_import(source_key: LearningContextKey, user_id: int, learning_package_id: int) -> _Import:
+def create_import(source_key: LearningContextKey, user_id: int) -> _Import:
     """
     Create a new import event to import a course to a library and save course to staged content.
     """
     import_from_modulestore = _Import.objects.create(
         source_key=source_key,
-        target_change_id=learning_package_id,
         user_id=user_id,
     )
     save_legacy_content_to_staged_content_task.delay_on_commit(import_from_modulestore.uuid)
@@ -24,9 +24,10 @@ def create_import(source_key: LearningContextKey, user_id: int, learning_package
 def import_course_staged_content_to_library(
     usage_ids: list[str],
     import_uuid: str,
+    target_learning_package_id: int,
     user_id: int,
     composition_level: str,
-    override: bool
+    override: bool,
 ) -> None:
     """
     Import staged content to a library from staged content.
@@ -36,6 +37,7 @@ def import_course_staged_content_to_library(
         kwargs={
             'usage_keys_string': usage_ids,
             'import_uuid': import_uuid,
+            'learning_package_id': target_learning_package_id,
             'user_id': user_id,
             'composition_level': composition_level,
             'override': override,
diff --git a/cms/djangoapps/import_from_modulestore/data.py b/cms/djangoapps/import_from_modulestore/data.py
index 0b0ff813cac6..0a891f2f30a3 100644
--- a/cms/djangoapps/import_from_modulestore/data.py
+++ b/cms/djangoapps/import_from_modulestore/data.py
@@ -1,6 +1,7 @@
 """
 This module contains the data models for the import_from_modulestore app.
 """
+from collections import namedtuple
 from enum import Enum
 
 from django.db.models import TextChoices
@@ -21,6 +22,7 @@ class ImportStatus(TextChoices):
     IMPORTED = 'imported', _('Successfully imported content')
     CANCELED = 'canceled', _('Canceled')
 
+
 class CompositionLevel(Enum):
     """
     Enumeration of composition levels for course content.
@@ -43,3 +45,6 @@ def values(cls):
         Returns all levels of composition levels.
         """
         return [composition_level.value for composition_level in cls]
+
+
+PublishableVersionWithMapping = namedtuple('PublishableVersionWithMapping', ['publishable_version', 'mapping'])
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index f5e749c1df1c..45bf022f73d9 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -14,14 +14,14 @@
 from opaque_keys.edx.keys import UsageKey
 from opaque_keys.edx.locator import CourseLocator, LibraryUsageLocatorV2
 from openedx_learning.api import authoring as authoring_api
-from openedx_learning.api.authoring_models import ContainerVersion
+from openedx_learning.api.authoring_models import Component, Container, ContainerVersion, PublishableEntity
 
 from openedx.core.djangoapps.content_libraries import api
 from openedx.core.djangoapps.content_staging import api as content_staging_api
 from xmodule.modulestore.django import modulestore
 
-from .data import CompositionLevel
-from .models import Import, PublishableEntityMapping, PublishableEntityImport
+from .data import CompositionLevel, PublishableVersionWithMapping
+from .models import Import, PublishableEntityMapping
 
 
 log = logging.getLogger(__name__)
@@ -53,22 +53,24 @@ def __init__(
         self,
         import_event: Import,
         block_usage_key_to_import: str,
+        target_learning_package: 'LearningPackage',
         staged_content: 'StagedContent',
         composition_level: str,
         override: bool = False,
     ):
         self.import_event = import_event
         self.block_usage_key_to_import = block_usage_key_to_import
+        self.learning_package = target_learning_package
         self.staged_content = staged_content
         self.composition_level = composition_level
         self.override = override
 
         self.user_id = import_event.user_id
-        self.content_library = import_event.target.contentlibrary
+        self.content_library = target_learning_package.contentlibrary
         self.library_key = self.content_library.library_key
         self.parser = etree.XMLParser(strip_cdata=False)
 
-    def import_from_staged_content(self):
+    def import_from_staged_content(self) -> list[PublishableVersionWithMapping]:
         """
         Import staged content into a library.
         """
@@ -76,11 +78,11 @@ def import_from_staged_content(self):
         usage_key = UsageKey.from_string(self.block_usage_key_to_import)
         block_to_import = get_block_to_import(node, usage_key)
         if block_to_import is None:
-            return
+            return []
 
-        self._process_import(self.block_usage_key_to_import, block_to_import)
+        return self._process_import(self.block_usage_key_to_import, block_to_import)
 
-    def _process_import(self, usage_id, block_to_import):
+    def _process_import(self, usage_key_string, block_to_import) -> list[PublishableVersionWithMapping]:
         """
         Process import of a block from staged content into a library.
 
@@ -88,7 +90,7 @@ def _process_import(self, usage_id, block_to_import):
         composition level. It handles both simple and complicated blocks, creating
         the necessary container hierarchy.
         """
-        usage_key = UsageKey.from_string(usage_id)
+        usage_key = UsageKey.from_string(usage_key_string)
         result = []
 
         if block_to_import.tag not in CompositionLevel.COMPLICATED_LEVELS.value:
@@ -100,36 +102,40 @@ def _process_import(self, usage_id, block_to_import):
             )
             if not child_usage_key_string:
                 continue
+
             result.extend(self._import_child_block(child, child_usage_key_string))
 
         if self.composition_level in CompositionLevel.FLAT_LEVELS.value:
-            return [component for component in result if not isinstance(component, ContainerVersion)]
+            return [
+                publishable_version_with_mapping for publishable_version_with_mapping in result
+                if not isinstance(publishable_version_with_mapping.publishable_version, ContainerVersion)
+            ]
         return result
 
-    def _import_simple_block(self, block_to_import, usage_key) -> list:
+    def _import_simple_block(self, block_to_import, usage_key) -> list[PublishableVersionWithMapping]:
         """
         Import a simple block into the library.
 
         Creates a block in the library from the staged content block.
         It returns a list containing the created component version.
         """
-        component_version = self._create_block_in_library(block_to_import, usage_key)
-        return [component_version] if component_version else []
+        publishable_version_with_mapping = self._create_block_in_library(block_to_import, usage_key)
+        return [publishable_version_with_mapping] if publishable_version_with_mapping else []
 
-    def _import_child_block(self, child, child_usage_id):
+    def _import_child_block(self, child, child_usage_key_string):
         """
         Import a child block into the library.
 
         Determines whether the child block is simple or complicated and
         delegates the import process to the appropriate helper method.
         """
-        child_usage_key = UsageKey.from_string(child_usage_id)
+        child_usage_key = UsageKey.from_string(child_usage_key_string)
         if child.tag in CompositionLevel.COMPLICATED_LEVELS.value:
-            return self._import_complicated_child(child, child_usage_id)
+            return self._import_complicated_child(child, child_usage_key_string)
         else:
             return self._import_simple_block(child, child_usage_key)
 
-    def _import_complicated_child(self, child, child_usage_id):
+    def _import_complicated_child(self, child, child_usage_key_string):
         """
         Import a complicated child block into the library.
 
@@ -137,19 +143,43 @@ def _import_complicated_child(self, child, child_usage_id):
         containers and updating components.
         Returns a list containing the created container version.
         """
-        if self.composition_level in CompositionLevel.FLAT_LEVELS.value:
-            return self._process_import(child_usage_id, child)
+        if not self._should_create_container(child.tag):
+            return self._process_import(child_usage_key_string, child)
 
-        container_version = self.get_or_create_container(
+        container_version_with_mapping = self.get_or_create_container(
             child.tag,
             child.get('url_name'),
-            child.get('display_name', child.tag)
+            child.get('display_name', child.tag),
+            child_usage_key_string,
         )
-        child_component_versions = self._process_import(child_usage_id, child)
-        self._update_container_components(container_version, child_component_versions)
-        return [container_version]
+        child_component_versions_with_mapping = self._process_import(child_usage_key_string, child)
+        child_component_versions = [
+            child_component_version.publishable_version for child_component_version
+            in child_component_versions_with_mapping
+        ]
+        self._update_container_components(container_version_with_mapping.publishable_version, child_component_versions)
+        return [container_version_with_mapping] + child_component_versions_with_mapping
 
-    def get_or_create_container(self, container_type, key, display_name):
+    def _should_create_container(self, container_type: str) -> bool:
+        """
+        Determine if a new container should be created.
+
+        Container type should be at a lower level than the current composition level.
+        """
+        composition_hierarchy = CompositionLevel.COMPLICATED_LEVELS.value
+        return (
+            container_type in composition_hierarchy and
+            self.composition_level in composition_hierarchy and
+            composition_hierarchy.index(container_type) >= composition_hierarchy.index(self.composition_level)
+        )
+
+    def get_or_create_container(
+        self,
+        container_type: str,
+        key: str,
+        display_name: str,
+        block_usage_key_string: str
+    ) -> PublishableVersionWithMapping:
         """
         Create a container of the specified type.
 
@@ -161,7 +191,11 @@ def get_or_create_container(self, container_type, key, display_name):
         if not all((container_creator_func, container_override_func)):
             raise ValueError(f"Unknown container type: {container_type}")
 
-        container_version = self.content_library.learning_package.publishable_entities.filter(key=key).first()
+        try:
+            container_version = self.content_library.learning_package.publishable_entities.get(key=key)
+        except PublishableEntity.DoesNotExist:
+            container_version = None
+
         if container_version and self.override:
             container_version = container_override_func(
                 container_version.container,
@@ -172,7 +206,7 @@ def get_or_create_container(self, container_type, key, display_name):
             )
         elif not container_version:
             _, container_version = container_creator_func(
-                self.import_event.target_id,
+                self.learning_package.id,
                 key=key or secrets.token_hex(16),
                 title=display_name or f"New {container_type}",
                 components=[],
@@ -180,7 +214,12 @@ def get_or_create_container(self, container_type, key, display_name):
                 created_by=self.import_event.user_id,
             )
 
-        return container_version
+        publishable_entity_mapping, _ = get_or_create_publishable_entity_mapping(
+            block_usage_key_string,
+            container_version.container
+        )
+
+        return PublishableVersionWithMapping(container_version, publishable_entity_mapping)
 
     def _update_container_components(self, container_version, component_versions):
         """
@@ -202,7 +241,7 @@ def _update_container_components(self, container_version, component_versions):
             container_version_cls=container_version.__class__,
         )
 
-    def _create_block_in_library(self, block_to_import, usage_key):
+    def _create_block_in_library(self, block_to_import, usage_key) -> PublishableVersionWithMapping | None:
         """
         Create a block in a library from a staged content block.
         """
@@ -212,7 +251,7 @@ def _create_block_in_library(self, block_to_import, usage_key):
         with transaction.atomic():
             component_type = authoring_api.get_or_create_component_type("xblock.v1", usage_key.block_type)
             does_component_exist = authoring_api.get_components(
-                self.import_event.target_id
+                self.learning_package.id
             ).filter(local_key=usage_key.block_id).exists()
 
             if does_component_exist:
@@ -233,7 +272,7 @@ def _create_block_in_library(self, block_to_import, usage_key):
                     return
 
                 authoring_api.create_component(
-                    self.import_event.target_id,
+                    self.learning_package.id,
                     component_type=component_type,
                     local_key=usage_key.block_id,
                     created=now,
@@ -248,24 +287,24 @@ def _create_block_in_library(self, block_to_import, usage_key):
                 block_to_import,
                 now,
             )
-            _create_publishable_entity_import(self.import_event, usage_key, component_version)
-
-            return component_version
+            publishable_entity_mapping, _ = get_or_create_publishable_entity_mapping(
+                usage_key,
+                component_version.component
+            )
+            return PublishableVersionWithMapping(component_version, publishable_entity_mapping)
 
     def _handle_component_override(self, usage_key, new_content):
         """
         Create new ComponentVersion for overridden component.
         """
         component_version = None
-        component = self.import_event.target.component_set.filter(local_key=usage_key.block_id).first()
+        try:
+            component = authoring_api.get_components(self.learning_package.id).get(local_key=usage_key.block_id)
+        except Component.DoesNotExist:
+            return component_version
+        library_usage_key = api.library_component_usage_key(self.library_key, component)
 
-        if component:
-            library_usage_key = LibraryUsageLocatorV2(  # type: ignore[abstract]
-                lib_key=self.library_key,
-                block_type=component.component_type.name,
-                usage_id=component.local_key,
-            )
-            component_version = api.set_library_block_olx(library_usage_key, new_content)
+        component_version = api.set_library_block_olx(library_usage_key, new_content)
 
         return component_version
 
@@ -313,7 +352,7 @@ def _process_staged_content_files(
 
             media_type = authoring_api.get_or_create_media_type(media_type_str)
             content = authoring_api.get_or_create_file_content(
-                self.import_event.target_id,
+                self.learning_package.id,
                 media_type.id,
                 data=file_data,
                 created=created_at,
@@ -325,29 +364,18 @@ def _process_staged_content_files(
                 pass  # Content already exists
 
 
-def _create_publishable_entity_import(import_event, usage_key, component_version) -> PublishableEntityImport:
-    """
-    Creates relations between the imported component and source usage key and import event.
-    """
-    publishable_entity_mapping, _ = _get_or_create_publishable_entity_mapping(
-        usage_key,
-        component_version.component
-    )
-    return PublishableEntityImport.objects.create(
-        import_event=import_event,
-        result=publishable_entity_mapping,
-        resulting_draft=component_version.publishable_entity_version,
-    )
-
-
-def _get_or_create_publishable_entity_mapping(usage_key, component) -> tuple[PublishableEntityMapping, bool]:
+def get_or_create_publishable_entity_mapping(usage_key, component) -> tuple[PublishableEntityMapping, bool]:
     """
     Creates a mapping between the source usage key and the target publishable entity.
     """
+    if isinstance(component, Container):
+        target_package = component.publishable_entity.learning_package
+    else:
+        target_package = component.learning_package
     return PublishableEntityMapping.objects.get_or_create(
         source_usage_key=usage_key,
         target_entity=component.publishable_entity,
-        target_package=component.learning_package
+        target_package=target_package,
     )
 
 
diff --git a/cms/djangoapps/import_from_modulestore/signals.py b/cms/djangoapps/import_from_modulestore/signals.py
index 958c7e365f67..d6d52e5d6b6b 100644
--- a/cms/djangoapps/import_from_modulestore/signals.py
+++ b/cms/djangoapps/import_from_modulestore/signals.py
@@ -18,7 +18,7 @@ def cancel_incomplete_imports(sender, instance, created, **kwargs):
     if created:
         incomplete_user_imports_with_same_target = Import.objects.filter(
             user=instance.user,
-            target=instance.target,
+            target_change=instance.target_change,
             source_key=instance.source_key,
             staged_content_for_import__isnull=False
         ).exclude(uuid=instance.uuid)
diff --git a/cms/djangoapps/import_from_modulestore/tasks.py b/cms/djangoapps/import_from_modulestore/tasks.py
index 643041c931e4..70c30f1d4517 100644
--- a/cms/djangoapps/import_from_modulestore/tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tasks.py
@@ -7,12 +7,14 @@
 from django.db import transaction
 from edx_django_utils.monitoring import set_code_owner_attribute
 
+from openedx_learning.api import authoring as authoring_api
+from openedx_learning.api.authoring_models import LearningPackage
 from openedx.core.djangoapps.content_staging import api as content_staging_api
 
 from .constants import IMPORT_FROM_MODULESTORE_PURPOSE
 from .data import ImportStatus
 from .helpers import get_items_to_import, ImportClient
-from .models import Import, StagedContentForImport
+from .models import Import, PublishableEntityImport, StagedContentForImport
 from .validators import validate_composition_level
 
 log = get_task_logger(__name__)
@@ -31,6 +33,7 @@ def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
         return
 
     import_event.clean_related_staged_content()
+    import_event.set_status(ImportStatus.STAGING)
     try:
         with transaction.atomic():
             items_to_import = get_items_to_import(import_event)
@@ -47,11 +50,11 @@ def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
                 )
 
             if items_to_import:
-                import_event.set_status(ImportStatus.READY)
+                import_event.set_status(ImportStatus.STAGED)
             else:
-                import_event.set_status(ImportStatus.ERROR)
+                import_event.set_status(ImportStatus.STAGING_FAILED)
     except Exception as exc:  # pylint: disable=broad-except
-        import_event.set_status(ImportStatus.ERROR)
+        import_event.set_status(ImportStatus.STAGING_FAILED)
         raise exc
 
 
@@ -60,30 +63,48 @@ def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
 def import_course_staged_content_to_library_task(
     usage_keys_string: list[str],
     import_uuid: str,
+    learning_package_id: int,
     user_id: int,
     composition_level: str,
-    override: bool
+    override: bool,
 ) -> None:
     """
     Import staged content to a library task.
     """
     validate_composition_level(composition_level)
     try:
-        import_event = Import.objects.get(uuid=import_uuid, status=ImportStatus.READY, user_id=user_id)
+        import_event = Import.objects.get(uuid=import_uuid, status=ImportStatus.STAGED, user_id=user_id)
     except Import.DoesNotExist:
         log.info('Ready import from modulestore not found')
         return
+    try:
+        target_learning_package = LearningPackage.objects.get(id=learning_package_id)
+    except Import.LearningPackage:
+        log.info('Target learning package not found')
+        return
 
-    with transaction.atomic():
-        for usage_key_string in usage_keys_string:
-            if staged_content_item := import_event.get_staged_content_by_source_usage_key(usage_key_string):  # FIXME
-                import_client = ImportClient(
-                    import_event,
-                    usage_key_string,
-                    staged_content_item,
-                    composition_level,
-                    override,
-                )
-                import_client.import_from_staged_content()
+    imported_publishable_versions = []
+    with authoring_api.bulk_draft_changes_for(learning_package_id=learning_package_id) as change_log:
+        try:
+            for usage_key_string in usage_keys_string:
+                if staged_content_item := import_event.get_staged_content_by_source_usage_key(usage_key_string):  # FIXME
+                    import_client = ImportClient(
+                        import_event,
+                        usage_key_string,
+                        target_learning_package,
+                        staged_content_item,
+                        composition_level,
+                        override,
+                    )
+                    imported_publishable_versions.extend(import_client.import_from_staged_content())
+        except Exception as exc:  # pylint: disable=broad-except
+            import_event.set_status(ImportStatus.IMPORTING_FAILED)
+            raise exc from exc  # FIXME retest raise and describe change_log commitment on Exception
 
-        import_event.set_status(ImportStatus.IMPORTED)
+    import_event.set_status(ImportStatus.IMPORTED)
+    for imported_component_version in imported_publishable_versions:
+        PublishableEntityImport.objects.create(
+            import_event=import_event,
+            resulting_mapping=imported_component_version.mapping,
+            resulting_change=change_log.records.get(entity=imported_component_version.mapping.target_entity),
+        )

From 60de98a6c08fd3b8860c76b52aba545318d210fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Fri, 18 Apr 2025 19:02:53 +0300
Subject: [PATCH 08/26] test: update tests

---
 .../tests/factories.py                        |   1 -
 .../import_from_modulestore/tests/test_api.py |  10 +-
 .../tests/test_helpers.py                     | 108 ++++++++----------
 .../tests/test_tasks.py                       |  14 ++-
 4 files changed, 62 insertions(+), 71 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/tests/factories.py b/cms/djangoapps/import_from_modulestore/tests/factories.py
index fabb99af2163..d5173ee14fd8 100644
--- a/cms/djangoapps/import_from_modulestore/tests/factories.py
+++ b/cms/djangoapps/import_from_modulestore/tests/factories.py
@@ -25,6 +25,5 @@ class Meta:
     def source_key(self):
         return CourseKey.from_string(f'course-v1:edX+DemoX+{self.uuid}')
 
-    target_change = factory.SubFactory(factories.LearningPackageFactory)
     uuid = factory.LazyFunction(lambda: str(uuid.uuid4()))
     user = factory.SubFactory(UserFactory)
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_api.py b/cms/djangoapps/import_from_modulestore/tests/test_api.py
index 5627b8b89e4f..4523fa440372 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_api.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_api.py
@@ -32,20 +32,18 @@ def test_create_import(self):
         """
         course_id = "course-v1:edX+DemoX+Demo_Course"
         user = UserFactory()
-        create_import(course_id, user.id, self.library.learning_package_id)
+        create_import(course_id, user.id)
 
         import_event = Import.objects.get()
         assert import_event.source_key == CourseKey.from_string(course_id)
-        assert import_event.target == self.library.learning_package
         assert import_event.user_id == user.id
-        assert import_event.status == ImportStatus.PENDING
+        assert import_event.status == ImportStatus.NOT_STARTED
 
     def test_import_course_staged_content_to_library(self):
         """
         Test import_course_staged_content_to_library function with different override values.
         """
         import_event = ImportFactory(
-            target=self.library.learning_package,
             source_key=CourseKey.from_string("course-v1:edX+DemoX+Demo_Course"),
         )
         usage_ids = [
@@ -60,6 +58,7 @@ def test_import_course_staged_content_to_library(self):
             import_course_staged_content_to_library(
                 usage_ids,
                 import_event.uuid,
+                self.library.learning_package.id,
                 import_event.user.id,
                 "xblock",
                 override
@@ -69,6 +68,7 @@ def test_import_course_staged_content_to_library(self):
             kwargs={
                 "usage_keys_string": usage_ids,
                 "import_uuid": import_event.uuid,
+                "learning_package_id": self.library.learning_package.id,
                 "user_id": import_event.user.id,
                 "composition_level": "xblock",
                 "override": override,
@@ -80,7 +80,6 @@ def test_import_course_staged_content_to_library_invalid_usage_key(self):
         Test import_course_staged_content_to_library function with not chapter usage keys.
         """
         import_event = ImportFactory(
-            target=self.library.learning_package,
             source_key=CourseKey.from_string("course-v1:edX+DemoX+Demo_Course"),
         )
         usage_ids = [
@@ -95,6 +94,7 @@ def test_import_course_staged_content_to_library_invalid_usage_key(self):
                 import_course_staged_content_to_library(
                     usage_ids,
                     import_event.uuid,
+                    self.library.learning_package.id,
                     import_event.user.id,
                     "xblock",
                     False
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
index 9c0b56d45bbd..2a50d5d281ea 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
@@ -32,6 +32,7 @@ def setUp(self):
             title='Library Org 1',
             description='This is a library from Org 1',
         )
+        self.learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
         self.user = UserFactory()
         self.course = CourseFactory.create()
         self.chapter = BlockFactory.create(category='chapter', parent=self.course, display_name='Chapter')
@@ -50,11 +51,7 @@ def setUp(self):
             data="""<video youtube="1.00:3_yD_cEKoCk" url_name="SampleProblem"/>""",
         )
         with self.captureOnCommitCallbacks(execute=True):
-            self.import_event = api.create_import(
-                source_key=self.course.id,
-                learning_package_id=self.library.learning_package_id,
-                user_id=self.user.id,
-            )
+            self.import_event = api.create_import(source_key=self.course.id, user_id=self.user.id)
         self.parser = etree.XMLParser(strip_cdata=False)
 
     def test_import_from_staged_content(self):
@@ -63,6 +60,7 @@ def test_import_from_staged_content(self):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=str(self.chapter.location),
             composition_level='xblock',
             override=False
@@ -70,8 +68,7 @@ def test_import_from_staged_content(self):
 
         import_client.import_from_staged_content()
 
-        learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
-        self.assertEqual(learning_package.content_set.count(), len(expected_imported_xblocks))
+        self.assertEqual(self.learning_package.content_set.count(), len(expected_imported_xblocks))
 
     @patch('cms.djangoapps.import_from_modulestore.helpers.ImportClient._process_import')
     def test_import_from_staged_content_block_not_found(self, mocked_process_import):
@@ -79,6 +76,7 @@ def test_import_from_staged_content_block_not_found(self, mocked_process_import)
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import='block-v1:edX+Demo+2025+type@chapter+block@12345',
             composition_level='xblock',
             override=False
@@ -86,8 +84,7 @@ def test_import_from_staged_content_block_not_found(self, mocked_process_import)
 
         import_client.import_from_staged_content()
 
-        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
-        self.assertTrue(not library_learning_package.content_set.count())
+        self.assertTrue(not self.learning_package.content_set.count())
         mocked_process_import.assert_not_called()
 
     @ddt.data('chapter', 'sequential', 'vertical')
@@ -98,6 +95,7 @@ def test_create_container(self, block_lvl):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
             override=False
@@ -105,11 +103,11 @@ def test_create_container(self, block_lvl):
         import_client.get_or_create_container(
             container_to_import.category,
             container_to_import.location.block_id,
-            container_to_import.display_name
+            container_to_import.display_name,
+            str(container_to_import.location)
         )
 
-        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
-        self.assertEqual(library_learning_package.publishable_entities.count(), 1)
+        self.assertEqual(self.learning_package.publishable_entities.count(), 1)
 
     def test_create_container_with_xblock(self):
         block_usage_key_to_import = str(self.problem.location)
@@ -117,6 +115,7 @@ def test_create_container_with_xblock(self):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
             override=False
@@ -125,7 +124,8 @@ def test_create_container_with_xblock(self):
             import_client.get_or_create_container(
                 self.problem.category,
                 self.problem.location.block_id,
-                self.problem.display_name
+                self.problem.display_name,
+                str(self.problem.location),
             )
 
     @ddt.data('chapter', 'sequential', 'vertical')
@@ -139,17 +139,16 @@ def test_process_import_with_complicated_blocks(self, block_lvl):
             import_event=self.import_event,
             staged_content=staged_content,
             block_usage_key_to_import=block_usage_key_to_import,
+            target_learning_package=self.learning_package,
             composition_level='xblock',
             override=False
         )
         block_to_import = etree.fromstring(staged_content.olx, parser=self.parser)
         # pylint: disable=protected-access
-        result = import_client._process_import(block_usage_key_to_import, block_to_import)
+        result = import_client.import_from_staged_content()
 
-        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
-        self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
+        self.assertEqual(self.learning_package.content_set.count(), len(expected_imported_xblocks))
         self.assertEqual(len(result), len(expected_imported_xblocks))
-        self.assertEqual(self.import_event.publishableentityimport_set.count(), len(expected_imported_xblocks))
 
     @ddt.data('problem', 'video')
     def test_process_import_with_simple_blocks(self, block_type_to_import):
@@ -160,6 +159,7 @@ def test_process_import_with_simple_blocks(self, block_type_to_import):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
             override=False
@@ -169,10 +169,8 @@ def test_process_import_with_simple_blocks(self, block_type_to_import):
         # pylint: disable=protected-access
         result = import_client._process_import(block_usage_key_to_import, block_to_import)
 
-        library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
-        self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
+        self.assertEqual(self.learning_package.content_set.count(), len(expected_imported_xblocks))
         self.assertEqual(len(result), len(expected_imported_xblocks))
-        self.assertEqual(self.import_event.publishableentityimport_set.count(), len(expected_imported_xblocks))
 
     @ddt.data(True, False)
     def test_process_import_with_override(self, override):
@@ -183,6 +181,7 @@ def test_process_import_with_override(self, override):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
             override=False
@@ -194,15 +193,12 @@ def test_process_import_with_override(self, override):
         self.assertEqual(len(result1), 1)
 
         with self.captureOnCommitCallbacks(execute=True):
-            new_import_event = api.create_import(
-                source_key=self.course.id,
-                learning_package_id=self.library.learning_package_id,
-                user_id=self.user.id,
-            )
+            new_import_event = api.create_import(source_key=self.course.id, user_id=self.user.id)
         new_staged_content = new_import_event.get_staged_content_by_source_usage_key(self.chapter.location)
         import_client = ImportClient(
             import_event=new_import_event,
             staged_content=new_staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
             override=override
@@ -221,7 +217,8 @@ def test_process_import_with_override(self, override):
             # pylint: disable=protected-access
             result2 = import_client._process_import(block_usage_key_to_import, block_xml)
             self.assertEqual(len(result2), 1)
-            assert result2[0].title == 'ModifiedName'
+
+            assert result2[0].publishable_version.title == 'ModifiedName'
         else:
             # pylint: disable=protected-access
             result2 = import_client._process_import(block_usage_key_to_import, block_xml)
@@ -236,37 +233,47 @@ def test_container_override(self, mock_authoring_api):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='vertical',
             override=False
         )
 
-        container_version = import_client.get_or_create_container(
+        container_version_with_mapping = import_client.get_or_create_container(
             'vertical',
             container_to_import.location.block_id,
-            container_to_import.display_name
+            container_to_import.display_name,
+            str(container_to_import.location),
         )
-        assert container_version is not None
-        assert container_version.title == container_to_import.display_name
+        assert container_version_with_mapping is not None
+        assert container_version_with_mapping.publishable_version.title == container_to_import.display_name
 
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='vertical',
             override=True
         )
-        overrided_container_version = import_client.get_or_create_container(
+        container_version_with_mapping = import_client.get_or_create_container(
             'vertical',
             container_to_import.location.block_id,
-            'New Display Name'
+            'New Display Name',
+            str(container_to_import.location),
         )
+        overrided_container_version = container_version_with_mapping.publishable_version
         assert overrided_container_version is not None
         assert overrided_container_version.title == 'New Display Name'
 
     @ddt.data('xblock', 'vertical')
     def test_composition_levels(self, composition_level):
-        expected_imported_blocks = [self.problem, self.video] if composition_level == 'xblock' else [self.vertical]
+        if composition_level == 'xblock':
+            expected_imported_blocks = [self.problem, self.video]
+        else:
+            # The vertical block is expected to be imported as a container
+            # with the same location as the original vertical block.
+            expected_imported_blocks = [self.vertical, self.problem, self.video]
 
         container_to_import = self.vertical
         block_usage_key_to_import = str(container_to_import.location)
@@ -275,6 +282,7 @@ def test_composition_levels(self, composition_level):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level=composition_level,
             override=False
@@ -295,6 +303,7 @@ def test_process_staged_content_files(self, mock_content_staging_api):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
             override=False
@@ -313,33 +322,13 @@ def test_process_staged_content_files(self, mock_content_staging_api):
             display_name='Problem With Image',
             data=modified_data,
         )
+        block_xml = etree.fromstring(modified_data, parser=self.parser)
 
-        with patch('cms.djangoapps.import_from_modulestore.helpers.authoring_api') as mock_authoring_api:
-            mock_component_type = mock.MagicMock()
-            mock_component_version = mock.MagicMock()
-            mock_media_type = mock.MagicMock()
-            mock_file_content = mock.MagicMock()
-
-            mock_authoring_api.get_or_create_component_type.return_value = mock_component_type
-            mock_authoring_api.get_components.return_value.filter.return_value.exists.return_value = False
-            mock_authoring_api.get_or_create_media_type.return_value = mock_media_type
-            mock_authoring_api.get_or_create_file_content.return_value = mock_file_content
-
-            with patch('cms.djangoapps.import_from_modulestore.helpers.api') as mock_api:
-                mock_api.validate_can_add_block_to_library.return_value = (None, None)
-                mock_api.set_library_block_olx.return_value = mock_component_version
-
-                with patch('cms.djangoapps.import_from_modulestore.helpers._create_publishable_entity_import'):
-                    block_xml = etree.fromstring(modified_data, parser=self.parser)
-
-                    # pylint: disable=protected-access
-                    import_client._create_block_in_library(block_xml, modified_block.location)
-
-                    mock_content_staging_api.get_staged_content_static_file_data.assert_called_once_with(
-                        staged_content.id, 'test.png'
-                    )
-                    mock_authoring_api.get_or_create_file_content.assert_called_once()
-                    mock_authoring_api.create_component_version_content.assert_called_once()
+        # pylint: disable=protected-access
+        import_client._create_block_in_library(block_xml, modified_block.location)
+        mock_content_staging_api.get_staged_content_static_file_data.assert_called_once_with(
+            staged_content.id, 'test.png'
+        )
 
     def test_update_container_components(self):
         container_to_import = self.vertical
@@ -349,6 +338,7 @@ def test_update_container_components(self):
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
+            target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='container',
             override=False
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
index 1e7123bec51d..33be9e667cf2 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
@@ -49,10 +49,7 @@ def setUp(self):
         self.video2 = BlockFactory.create(category='video', parent=self.vertical2, display_name='Video 2')
         self.problem2 = BlockFactory.create(category='problem', parent=self.vertical2, display_name='Problem 2')
 
-        self.import_event = ImportFactory(
-            source_key=self.course.id,
-            target=self.content_library.learning_package,
-        )
+        self.import_event = ImportFactory(source_key=self.course.id)
         self.user = self.import_event.user
 
 
@@ -70,7 +67,7 @@ def test_save_legacy_content_to_staged_content_task(self):
 
         self.import_event.refresh_from_db()
         self.assertEqual(self.import_event.staged_content_for_import.count(), len(course_chapters_to_import))
-        self.assertEqual(self.import_event.status, ImportStatus.READY)
+        self.assertEqual(self.import_event.status, ImportStatus.STAGED)
 
     def test_old_staged_content_deletion_before_save_new(self):
         """ Checking that repeated saving of the same content does not create duplicates. """
@@ -104,6 +101,7 @@ def test_import_course_staged_content_to_library_task(self):
         import_course_staged_content_to_library_task(
             [str(self.chapter.location), str(self.chapter2.location)],
             self.import_event.uuid,
+            self.content_library.learning_package.id,
             self.user.id,
             'xblock',
             override=True
@@ -117,6 +115,7 @@ def test_import_course_staged_content_to_library_task(self):
 
         library_learning_package.refresh_from_db()
         self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
+        self.assertEqual(self.import_event.publishableentityimport_set.count(), len(expected_imported_xblocks))
 
     @patch('cms.djangoapps.import_from_modulestore.tasks.ImportClient')
     def test_import_library_block_not_found(self, mock_import_client):
@@ -127,6 +126,7 @@ def test_import_library_block_not_found(self, mock_import_client):
         import_course_staged_content_to_library_task(
             non_existent_usage_ids,
             str(self.import_event.uuid),
+            self.content_library.learning_package.id,
             self.user.id,
             'xblock',
             override=True,
@@ -144,11 +144,12 @@ def test_cannot_import_staged_content_twice(self):
 
         self.import_event.refresh_from_db()
         self.assertEqual(self.import_event.staged_content_for_import.count(), len(chapters_to_import))
-        self.assertEqual(self.import_event.status, ImportStatus.READY)
+        self.assertEqual(self.import_event.status, ImportStatus.STAGED)
 
         import_course_staged_content_to_library_task(
             [str(self.chapter.location)],
             str(self.import_event.uuid),
+            self.content_library.learning_package.id,
             self.user.id,
             'xblock',
             override=True,
@@ -163,3 +164,4 @@ def test_cannot_import_staged_content_twice(self):
         self.import_event.refresh_from_db()
         self.assertEqual(self.import_event.status, ImportStatus.IMPORTED)
         self.assertTrue(not self.import_event.staged_content_for_import.exists())
+        self.assertEqual(self.import_event.publishableentityimport_set.count(), len(expected_imported_xblocks))

From ee3f843f16bc99295b5a8df3d1b09e37a6b5c48b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Fri, 18 Apr 2025 19:10:44 +0300
Subject: [PATCH 09/26] style: remove extra imports

---
 cms/djangoapps/import_from_modulestore/api.py             | 1 -
 cms/djangoapps/import_from_modulestore/helpers.py         | 2 +-
 cms/djangoapps/import_from_modulestore/tasks.py           | 4 ++--
 cms/djangoapps/import_from_modulestore/tests/factories.py | 1 -
 4 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
index 8e12726d385f..2136a295b716 100644
--- a/cms/djangoapps/import_from_modulestore/api.py
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -2,7 +2,6 @@
 API for course to library import.
 """
 from opaque_keys.edx.keys import LearningContextKey
-from openedx_learning.api import authoring as authoring_api
 
 from .models import Import as _Import
 from .tasks import import_course_staged_content_to_library_task, save_legacy_content_to_staged_content_task
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 45bf022f73d9..12a2505d726b 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -12,7 +12,7 @@
 from lxml import etree
 
 from opaque_keys.edx.keys import UsageKey
-from opaque_keys.edx.locator import CourseLocator, LibraryUsageLocatorV2
+from opaque_keys.edx.locator import CourseLocator
 from openedx_learning.api import authoring as authoring_api
 from openedx_learning.api.authoring_models import Component, Container, ContainerVersion, PublishableEntity
 
diff --git a/cms/djangoapps/import_from_modulestore/tasks.py b/cms/djangoapps/import_from_modulestore/tasks.py
index 70c30f1d4517..c13feee30561 100644
--- a/cms/djangoapps/import_from_modulestore/tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tasks.py
@@ -87,7 +87,7 @@ def import_course_staged_content_to_library_task(
     with authoring_api.bulk_draft_changes_for(learning_package_id=learning_package_id) as change_log:
         try:
             for usage_key_string in usage_keys_string:
-                if staged_content_item := import_event.get_staged_content_by_source_usage_key(usage_key_string):  # FIXME
+                if staged_content_item := import_event.get_staged_content_by_source_usage_key(usage_key_string):
                     import_client = ImportClient(
                         import_event,
                         usage_key_string,
@@ -99,7 +99,7 @@ def import_course_staged_content_to_library_task(
                     imported_publishable_versions.extend(import_client.import_from_staged_content())
         except Exception as exc:  # pylint: disable=broad-except
             import_event.set_status(ImportStatus.IMPORTING_FAILED)
-            raise exc from exc  # FIXME retest raise and describe change_log commitment on Exception
+            raise exc from exc  # TODO: retest raise and describe change_log commitment on Exception
 
     import_event.set_status(ImportStatus.IMPORTED)
     for imported_component_version in imported_publishable_versions:
diff --git a/cms/djangoapps/import_from_modulestore/tests/factories.py b/cms/djangoapps/import_from_modulestore/tests/factories.py
index d5173ee14fd8..368cc0ed94ff 100644
--- a/cms/djangoapps/import_from_modulestore/tests/factories.py
+++ b/cms/djangoapps/import_from_modulestore/tests/factories.py
@@ -10,7 +10,6 @@
 
 from common.djangoapps.student.tests.factories import UserFactory
 from cms.djangoapps.import_from_modulestore.models import Import
-from openedx.core.djangoapps.content_libraries.tests import factories
 
 
 class ImportFactory(DjangoModelFactory):

From 3e31032d306fc58f063c9b433ee99cd73bd9d2a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Tue, 22 Apr 2025 17:42:11 +0300
Subject: [PATCH 10/26] refactor: signal logic moved to the seprate util

---
 cms/djangoapps/import_from_modulestore/api.py |  7 +++--
 .../import_from_modulestore/helpers.py        | 18 ++++++++++++-
 .../import_from_modulestore/signals.py        | 26 -------------------
 3 files changed, 20 insertions(+), 31 deletions(-)
 delete mode 100644 cms/djangoapps/import_from_modulestore/signals.py

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
index 2136a295b716..8f5478e94737 100644
--- a/cms/djangoapps/import_from_modulestore/api.py
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -3,6 +3,7 @@
 """
 from opaque_keys.edx.keys import LearningContextKey
 
+from .helpers import cancel_incomplete_old_imports
 from .models import Import as _Import
 from .tasks import import_course_staged_content_to_library_task, save_legacy_content_to_staged_content_task
 from .validators import validate_usage_keys_to_import
@@ -12,10 +13,8 @@ def create_import(source_key: LearningContextKey, user_id: int) -> _Import:
     """
     Create a new import event to import a course to a library and save course to staged content.
     """
-    import_from_modulestore = _Import.objects.create(
-        source_key=source_key,
-        user_id=user_id,
-    )
+    import_from_modulestore = _Import.objects.create(source_key=source_key, user_id=user_id)
+    cancel_incomplete_old_imports(import_from_modulestore)
     save_legacy_content_to_staged_content_task.delay_on_commit(import_from_modulestore.uuid)
     return import_from_modulestore
 
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 12a2505d726b..0f6b4ada33e2 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -20,7 +20,7 @@
 from openedx.core.djangoapps.content_staging import api as content_staging_api
 from xmodule.modulestore.django import modulestore
 
-from .data import CompositionLevel, PublishableVersionWithMapping
+from .data import CompositionLevel, ImportStatus, PublishableVersionWithMapping
 from .models import Import, PublishableEntityMapping
 
 
@@ -414,3 +414,19 @@ def get_items_to_import(import_event):
         )
 
     return items_to_import
+
+
+def cancel_incomplete_old_imports(instance):
+    """
+    Cancel any incomplete imports that have the same target as the current import.
+
+    When a new import is created, we want to cancel any other incomplete user imports that have the same target.
+    """
+    incomplete_user_imports_with_same_target = Import.objects.filter(
+        user=instance.user,
+        target_change=instance.target_change,
+        source_key=instance.source_key,
+        staged_content_for_import__isnull=False
+    ).exclude(uuid=instance.uuid)
+    for incomplete_import in incomplete_user_imports_with_same_target:
+        incomplete_import.set_status(ImportStatus.CANCELED)
diff --git a/cms/djangoapps/import_from_modulestore/signals.py b/cms/djangoapps/import_from_modulestore/signals.py
deleted file mode 100644
index d6d52e5d6b6b..000000000000
--- a/cms/djangoapps/import_from_modulestore/signals.py
+++ /dev/null
@@ -1,26 +0,0 @@
-"""
-Signals for Import.
-"""
-from django.dispatch import receiver
-from django.db.models.signals import post_save
-
-from .data import ImportStatus
-from .models import Import
-
-
-@receiver(post_save, sender=Import)
-def cancel_incomplete_imports(sender, instance, created, **kwargs):
-    """
-    Cancel any incomplete imports that have the same target as the current import.
-
-    When a new import is created, we want to cancel any other incomplete user imports that have the same target.
-    """
-    if created:
-        incomplete_user_imports_with_same_target = Import.objects.filter(
-            user=instance.user,
-            target_change=instance.target_change,
-            source_key=instance.source_key,
-            staged_content_for_import__isnull=False
-        ).exclude(uuid=instance.uuid)
-        for incomplete_import in incomplete_user_imports_with_same_target:
-            incomplete_import.set_status(ImportStatus.CANCELED)

From 359b2bc7704f4bbe75798446b96e96f28c576fe5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Tue, 22 Apr 2025 17:45:11 +0300
Subject: [PATCH 11/26] refactor: rename purpose

---
 cms/djangoapps/import_from_modulestore/constants.py | 2 +-
 cms/djangoapps/import_from_modulestore/tasks.py     | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/constants.py b/cms/djangoapps/import_from_modulestore/constants.py
index 099acfbc2b7b..09e0d4e30f1a 100644
--- a/cms/djangoapps/import_from_modulestore/constants.py
+++ b/cms/djangoapps/import_from_modulestore/constants.py
@@ -2,4 +2,4 @@
 Constants for import_from_modulestore app
 """
 
-IMPORT_FROM_MODULESTORE_PURPOSE = "import_from_modulestore"
+IMPORT_FROM_MODULESTORE_STAGING_PURPOSE = "import_from_modulestore"
diff --git a/cms/djangoapps/import_from_modulestore/tasks.py b/cms/djangoapps/import_from_modulestore/tasks.py
index c13feee30561..97fc1901d56c 100644
--- a/cms/djangoapps/import_from_modulestore/tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tasks.py
@@ -11,7 +11,7 @@
 from openedx_learning.api.authoring_models import LearningPackage
 from openedx.core.djangoapps.content_staging import api as content_staging_api
 
-from .constants import IMPORT_FROM_MODULESTORE_PURPOSE
+from .constants import IMPORT_FROM_MODULESTORE_STAGING_PURPOSE
 from .data import ImportStatus
 from .helpers import get_items_to_import, ImportClient
 from .models import Import, PublishableEntityImport, StagedContentForImport
@@ -41,7 +41,7 @@ def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
                 staged_content = content_staging_api.stage_xblock_temporarily(
                     item,
                     import_event.user.id,
-                    purpose=IMPORT_FROM_MODULESTORE_PURPOSE,
+                    purpose=IMPORT_FROM_MODULESTORE_STAGING_PURPOSE,
                 )
                 StagedContentForImport.objects.create(
                     staged_content=staged_content,

From 9abe4fcf78cf351550e37a2d8debce138a88a414 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Tue, 22 Apr 2025 17:50:08 +0300
Subject: [PATCH 12/26] refactor: rename APIs

---
 cms/djangoapps/import_from_modulestore/api.py |  8 ++---
 .../import_from_modulestore/tasks.py          |  2 +-
 .../import_from_modulestore/tests/test_api.py | 32 +++++++++----------
 .../tests/test_helpers.py                     |  4 +--
 .../tests/test_tasks.py                       | 14 ++++----
 5 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
index 8f5478e94737..6d3d503602d6 100644
--- a/cms/djangoapps/import_from_modulestore/api.py
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -5,11 +5,11 @@
 
 from .helpers import cancel_incomplete_old_imports
 from .models import Import as _Import
-from .tasks import import_course_staged_content_to_library_task, save_legacy_content_to_staged_content_task
+from .tasks import import_staged_content_to_library_task, save_legacy_content_to_staged_content_task
 from .validators import validate_usage_keys_to_import
 
 
-def create_import(source_key: LearningContextKey, user_id: int) -> _Import:
+def stage_content_for_import(source_key: LearningContextKey, user_id: int) -> _Import:
     """
     Create a new import event to import a course to a library and save course to staged content.
     """
@@ -19,7 +19,7 @@ def create_import(source_key: LearningContextKey, user_id: int) -> _Import:
     return import_from_modulestore
 
 
-def import_course_staged_content_to_library(
+def import_staged_content_to_library(
     usage_ids: list[str],
     import_uuid: str,
     target_learning_package_id: int,
@@ -31,7 +31,7 @@ def import_course_staged_content_to_library(
     Import staged content to a library from staged content.
     """
     validate_usage_keys_to_import(usage_ids)
-    import_course_staged_content_to_library_task.apply_async(
+    import_staged_content_to_library_task.apply_async(
         kwargs={
             'usage_keys_string': usage_ids,
             'import_uuid': import_uuid,
diff --git a/cms/djangoapps/import_from_modulestore/tasks.py b/cms/djangoapps/import_from_modulestore/tasks.py
index 97fc1901d56c..bce12a004419 100644
--- a/cms/djangoapps/import_from_modulestore/tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tasks.py
@@ -60,7 +60,7 @@ def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
 
 @shared_task
 @set_code_owner_attribute
-def import_course_staged_content_to_library_task(
+def import_staged_content_to_library_task(
     usage_keys_string: list[str],
     import_uuid: str,
     learning_package_id: int,
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_api.py b/cms/djangoapps/import_from_modulestore/tests/test_api.py
index 4523fa440372..0b87c31b8b01 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_api.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_api.py
@@ -7,7 +7,7 @@
 from opaque_keys.edx.keys import CourseKey
 
 from common.djangoapps.student.tests.factories import UserFactory
-from cms.djangoapps.import_from_modulestore.api import create_import, import_course_staged_content_to_library
+from cms.djangoapps.import_from_modulestore.api import import_staged_content_to_library, stage_content_for_import
 from cms.djangoapps.import_from_modulestore.data import ImportStatus
 from cms.djangoapps.import_from_modulestore.models import Import
 from openedx.core.djangoapps.content_libraries.tests import factories
@@ -26,22 +26,22 @@ def setUp(self):
 
         self.library = factories.ContentLibraryFactory()
 
-    def test_create_import(self):
+    def test_stage_content_for_import(self):
         """
-        Test create_import function.
+        Test stage_content_for_import function.
         """
         course_id = "course-v1:edX+DemoX+Demo_Course"
         user = UserFactory()
-        create_import(course_id, user.id)
+        stage_content_for_import(course_id, user.id)
 
         import_event = Import.objects.get()
         assert import_event.source_key == CourseKey.from_string(course_id)
         assert import_event.user_id == user.id
         assert import_event.status == ImportStatus.NOT_STARTED
 
-    def test_import_course_staged_content_to_library(self):
+    def test_import_staged_content_to_library(self):
         """
-        Test import_course_staged_content_to_library function with different override values.
+        Test import_staged_content_to_library function with different override values.
         """
         import_event = ImportFactory(
             source_key=CourseKey.from_string("course-v1:edX+DemoX+Demo_Course"),
@@ -53,9 +53,9 @@ def test_import_course_staged_content_to_library(self):
         override = False
 
         with patch(
-            "cms.djangoapps.import_from_modulestore.api.import_course_staged_content_to_library_task"
-        ) as import_course_staged_content_to_library_task_mock:
-            import_course_staged_content_to_library(
+            "cms.djangoapps.import_from_modulestore.api.import_staged_content_to_library_task"
+        ) as import_staged_content_to_library_task_mock:
+            import_staged_content_to_library(
                 usage_ids,
                 import_event.uuid,
                 self.library.learning_package.id,
@@ -64,7 +64,7 @@ def test_import_course_staged_content_to_library(self):
                 override
             )
 
-        import_course_staged_content_to_library_task_mock.apply_async.assert_called_once_with(
+        import_staged_content_to_library_task_mock.apply_async.assert_called_once_with(
             kwargs={
                 "usage_keys_string": usage_ids,
                 "import_uuid": import_event.uuid,
@@ -75,9 +75,9 @@ def test_import_course_staged_content_to_library(self):
             },
         )
 
-    def test_import_course_staged_content_to_library_invalid_usage_key(self):
+    def test_import_staged_content_to_library_invalid_usage_key(self):
         """
-        Test import_course_staged_content_to_library function with not chapter usage keys.
+        Test import_staged_content_to_library function with not chapter usage keys.
         """
         import_event = ImportFactory(
             source_key=CourseKey.from_string("course-v1:edX+DemoX+Demo_Course"),
@@ -88,10 +88,10 @@ def test_import_course_staged_content_to_library_invalid_usage_key(self):
         ]
 
         with patch(
-            "cms.djangoapps.import_from_modulestore.api.import_course_staged_content_to_library_task"
-        ) as import_course_staged_content_to_library_task_mock:
+            "cms.djangoapps.import_from_modulestore.api.import_staged_content_to_library_task"
+        ) as import_staged_content_to_library_task_mock:
             with self.assertRaises(ValueError):
-                import_course_staged_content_to_library(
+                import_staged_content_to_library(
                     usage_ids,
                     import_event.uuid,
                     self.library.learning_package.id,
@@ -99,4 +99,4 @@ def test_import_course_staged_content_to_library_invalid_usage_key(self):
                     "xblock",
                     False
                 )
-        import_course_staged_content_to_library_task_mock.apply_async.assert_not_called()
+        import_staged_content_to_library_task_mock.apply_async.assert_not_called()
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
index 2a50d5d281ea..ca566150cca5 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
@@ -51,7 +51,7 @@ def setUp(self):
             data="""<video youtube="1.00:3_yD_cEKoCk" url_name="SampleProblem"/>""",
         )
         with self.captureOnCommitCallbacks(execute=True):
-            self.import_event = api.create_import(source_key=self.course.id, user_id=self.user.id)
+            self.import_event = api.stage_content_for_import(source_key=self.course.id, user_id=self.user.id)
         self.parser = etree.XMLParser(strip_cdata=False)
 
     def test_import_from_staged_content(self):
@@ -193,7 +193,7 @@ def test_process_import_with_override(self, override):
         self.assertEqual(len(result1), 1)
 
         with self.captureOnCommitCallbacks(execute=True):
-            new_import_event = api.create_import(source_key=self.course.id, user_id=self.user.id)
+            new_import_event = api.stage_content_for_import(source_key=self.course.id, user_id=self.user.id)
         new_staged_content = new_import_event.get_staged_content_by_source_usage_key(self.chapter.location)
         import_client = ImportClient(
             import_event=new_import_event,
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
index 33be9e667cf2..cf6ae7471f41 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
@@ -7,7 +7,7 @@
 
 from cms.djangoapps.import_from_modulestore.data import ImportStatus
 from cms.djangoapps.import_from_modulestore.tasks import (
-    import_course_staged_content_to_library_task,
+    import_staged_content_to_library_task,
     save_legacy_content_to_staged_content_task,
 )
 from openedx.core.djangoapps.content_libraries import api as content_libraries_api
@@ -84,21 +84,21 @@ def test_old_staged_content_deletion_before_save_new(self):
 
 class TestImportLibraryFromStagedContentTask(ImportCourseToLibraryMixin):
     """
-    Test cases for import_course_staged_content_to_library_task.
+    Test cases for import_staged_content_to_library_task.
     """
 
     def _is_imported(self, library, xblock):
         library_learning_package = LearningPackage.objects.get(id=library.learning_package_id)
         self.assertTrue(library_learning_package.content_set.filter(text__icontains=xblock.display_name).exists())
 
-    def test_import_course_staged_content_to_library_task(self):
-        """ End-to-end test for import_course_staged_content_to_library_task. """
+    def test_import_staged_content_to_library_task(self):
+        """ End-to-end test for import_staged_content_to_library_task. """
         library_learning_package = LearningPackage.objects.get(id=self.library.learning_package_id)
         self.assertEqual(library_learning_package.content_set.count(), 0)
         expected_imported_xblocks = [self.problem, self.problem2, self.video, self.video2]
         save_legacy_content_to_staged_content_task(self.import_event.uuid)
 
-        import_course_staged_content_to_library_task(
+        import_staged_content_to_library_task(
             [str(self.chapter.location), str(self.chapter2.location)],
             self.import_event.uuid,
             self.content_library.learning_package.id,
@@ -123,7 +123,7 @@ def test_import_library_block_not_found(self, mock_import_client):
         non_existent_usage_ids = ['block-v1:edX+Demo+2023+type@vertical+block@12345']
         save_legacy_content_to_staged_content_task(self.import_event.uuid)
 
-        import_course_staged_content_to_library_task(
+        import_staged_content_to_library_task(
             non_existent_usage_ids,
             str(self.import_event.uuid),
             self.content_library.learning_package.id,
@@ -146,7 +146,7 @@ def test_cannot_import_staged_content_twice(self):
         self.assertEqual(self.import_event.staged_content_for_import.count(), len(chapters_to_import))
         self.assertEqual(self.import_event.status, ImportStatus.STAGED)
 
-        import_course_staged_content_to_library_task(
+        import_staged_content_to_library_task(
             [str(self.chapter.location)],
             str(self.import_event.uuid),
             self.content_library.learning_package.id,

From 3aa550e5eb90cc38ec4a87b4031587981060595d Mon Sep 17 00:00:00 2001
From: Max Sokolski <cmltawt0@gmail.com>
Date: Tue, 22 Apr 2025 18:22:42 +0300
Subject: [PATCH 13/26] test: avoid using factories for content_library (#2635)

---
 .../import_from_modulestore/tests/test_api.py | 11 +++++-
 .../content_libraries/tests/factories.py      | 39 -------------------
 setup.cfg                                     |  1 -
 3 files changed, 9 insertions(+), 42 deletions(-)
 delete mode 100644 openedx/core/djangoapps/content_libraries/tests/factories.py

diff --git a/cms/djangoapps/import_from_modulestore/tests/test_api.py b/cms/djangoapps/import_from_modulestore/tests/test_api.py
index 0b87c31b8b01..02cefcb19a36 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_api.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_api.py
@@ -5,12 +5,13 @@
 
 import pytest
 from opaque_keys.edx.keys import CourseKey
+from organizations.models import Organization
 
 from common.djangoapps.student.tests.factories import UserFactory
 from cms.djangoapps.import_from_modulestore.api import import_staged_content_to_library, stage_content_for_import
 from cms.djangoapps.import_from_modulestore.data import ImportStatus
 from cms.djangoapps.import_from_modulestore.models import Import
-from openedx.core.djangoapps.content_libraries.tests import factories
+from openedx.core.djangoapps.content_libraries import api as content_libraries_api
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from .factories import ImportFactory
 
@@ -24,7 +25,13 @@ class TestCourseToLibraryImportAPI(ModuleStoreTestCase):
     def setUp(self):
         super().setUp()
 
-        self.library = factories.ContentLibraryFactory()
+        _library_metadata = content_libraries_api.create_library(
+            org=Organization.objects.create(name='Organization 1', short_name='org1'),
+            slug='lib_1',
+            title='Library Org 1',
+            description='This is a library from Org 1',
+        )
+        self.library = content_libraries_api.ContentLibrary.objects.get_by_key(_library_metadata.key)
 
     def test_stage_content_for_import(self):
         """
diff --git a/openedx/core/djangoapps/content_libraries/tests/factories.py b/openedx/core/djangoapps/content_libraries/tests/factories.py
deleted file mode 100644
index 5914370a409a..000000000000
--- a/openedx/core/djangoapps/content_libraries/tests/factories.py
+++ /dev/null
@@ -1,39 +0,0 @@
-"""
-Factories for content_libraries models.
-"""
-import factory
-import uuid
-from factory.django import DjangoModelFactory
-from organizations.tests.factories import OrganizationFactory
-
-from openedx_learning.api.authoring_models import LearningPackage
-from openedx.core.djangoapps.content_libraries.api import ContentLibrary
-
-
-class LearningPackageFactory(DjangoModelFactory):
-    """
-    Factory for LearningPackage model.
-    """
-
-    class Meta:
-        model = LearningPackage
-
-    title = factory.Faker('sentence')
-    description = factory.Faker('sentence')
-    uuid = factory.LazyFunction(lambda: str(uuid.uuid4()))
-    created = factory.Faker('date_time')
-    updated = factory.Faker('date_time')
-
-
-class ContentLibraryFactory(DjangoModelFactory):
-    """
-    Factory for ContentLibrary model.
-    """
-
-    class Meta:
-        model = ContentLibrary
-
-    org = factory.SubFactory(OrganizationFactory)
-    license = factory.Faker('sentence')
-    slug = factory.Faker('slug')
-    learning_package = factory.SubFactory(LearningPackageFactory)
diff --git a/setup.cfg b/setup.cfg
index e30f66da9c16..d83ae7d2765e 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -183,7 +183,6 @@ allowed_modules =
     # See https://open-edx-proposals.readthedocs.io/en/latest/best-practices/oep-0049-django-app-patterns.html#api-py
     api
     data
-    tests.factories
 
 [importlinter:contract:3]
 name = Do not import apps from openedx-learning (only import from openedx_learning.api.* and openedx_learning.lib.*).

From 15fe9e51832446ab4f6b26a8f36d77e98c65669c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Tue, 22 Apr 2025 18:30:19 +0300
Subject: [PATCH 14/26] refactor: refactor CompositionLevel enum

---
 .../import_from_modulestore/data.py           |  7 ++++--
 .../import_from_modulestore/helpers.py        | 22 +++++++++++--------
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/data.py b/cms/djangoapps/import_from_modulestore/data.py
index 0a891f2f30a3..d600060ef522 100644
--- a/cms/djangoapps/import_from_modulestore/data.py
+++ b/cms/djangoapps/import_from_modulestore/data.py
@@ -36,8 +36,11 @@ class CompositionLevel(Enum):
     SEQUENTIAL = 'sequential'
     VERTICAL = 'vertical'
     XBLOCK = 'xblock'
-    COMPLICATED_LEVELS = [CHAPTER, SEQUENTIAL, VERTICAL]
-    FLAT_LEVELS = [XBLOCK]
+    COMPLEX_LEVELS = [
+        VERTICAL,
+        SEQUENTIAL,
+        CHAPTER,
+    ]
 
     @classmethod
     def values(cls):
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 0f6b4ada33e2..80a837ee2bba 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -38,14 +38,18 @@ class ImportClient:
     """
 
     CONTAINER_CREATORS_MAP = {
-        'chapter': authoring_api.create_unit_and_version,  # TODO: replace with create_module_and_version
-        'sequential': authoring_api.create_unit_and_version,  # TODO: replace with create_section_and_version
+        # Sequential- and Chapter-level composition to be added in the future as part of
+        # https://github.com/openedx/frontend-app-authoring/issues/1602
+        # 'chapter': authoring_api.create_unit_and_version,  # TODO: replace with create_module_and_version
+        # 'sequential': authoring_api.create_unit_and_version,  # TODO: replace with create_section_and_version
         'vertical': authoring_api.create_unit_and_version,
     }
 
     CONTAINER_OVERRIDERS_MAP = {
-        'chapter': authoring_api.create_next_unit_version,  # TODO: replace with create_next_module_version
-        'sequential': authoring_api.create_next_unit_version,  # TODO: replace with create_next_section_version
+        # Sequential- and Chapter-level composition to be added in the future as part of
+        # https://github.com/openedx/frontend-app-authoring/issues/1602
+        # 'chapter': authoring_api.create_next_unit_version,  # TODO: replace with create_next_module_version
+        # 'sequential': authoring_api.create_next_unit_version,  # TODO: replace with create_next_section_version
         'vertical': authoring_api.create_next_unit_version,
     }
 
@@ -93,7 +97,7 @@ def _process_import(self, usage_key_string, block_to_import) -> list[Publishable
         usage_key = UsageKey.from_string(usage_key_string)
         result = []
 
-        if block_to_import.tag not in CompositionLevel.COMPLICATED_LEVELS.value:
+        if block_to_import.tag not in CompositionLevel.COMPLEX_LEVELS.value:
             return self._import_simple_block(block_to_import, usage_key)
 
         for child in block_to_import.getchildren():
@@ -105,7 +109,7 @@ def _process_import(self, usage_key_string, block_to_import) -> list[Publishable
 
             result.extend(self._import_child_block(child, child_usage_key_string))
 
-        if self.composition_level in CompositionLevel.FLAT_LEVELS.value:
+        if self.composition_level == CompositionLevel.XBLOCK.value:
             return [
                 publishable_version_with_mapping for publishable_version_with_mapping in result
                 if not isinstance(publishable_version_with_mapping.publishable_version, ContainerVersion)
@@ -130,7 +134,7 @@ def _import_child_block(self, child, child_usage_key_string):
         delegates the import process to the appropriate helper method.
         """
         child_usage_key = UsageKey.from_string(child_usage_key_string)
-        if child.tag in CompositionLevel.COMPLICATED_LEVELS.value:
+        if child.tag in CompositionLevel.COMPLEX_LEVELS.value:
             return self._import_complicated_child(child, child_usage_key_string)
         else:
             return self._import_simple_block(child, child_usage_key)
@@ -166,11 +170,11 @@ def _should_create_container(self, container_type: str) -> bool:
 
         Container type should be at a lower level than the current composition level.
         """
-        composition_hierarchy = CompositionLevel.COMPLICATED_LEVELS.value
+        composition_hierarchy = CompositionLevel.COMPLEX_LEVELS.value
         return (
             container_type in composition_hierarchy and
             self.composition_level in composition_hierarchy and
-            composition_hierarchy.index(container_type) >= composition_hierarchy.index(self.composition_level)
+            composition_hierarchy.index(container_type) <= composition_hierarchy.index(self.composition_level)
         )
 
     def get_or_create_container(

From 5ff0620f2908f983387fd93afef4187e1efd27e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Tue, 22 Apr 2025 18:43:35 +0300
Subject: [PATCH 15/26] fix: fix logic for not yet supported composition levels

---
 cms/djangoapps/import_from_modulestore/data.py     | 14 ++++++++++++++
 .../import_from_modulestore/validators.py          |  2 +-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/cms/djangoapps/import_from_modulestore/data.py b/cms/djangoapps/import_from_modulestore/data.py
index d600060ef522..e405713dead9 100644
--- a/cms/djangoapps/import_from_modulestore/data.py
+++ b/cms/djangoapps/import_from_modulestore/data.py
@@ -49,5 +49,19 @@ def values(cls):
         """
         return [composition_level.value for composition_level in cls]
 
+    @classmethod
+    def supported_levels(cls):
+        """
+        Returns all supported levels of composition levels.
+
+        # TEMPORARY: This is a temporary solution to support the
+        # import from modulestore to learning core for the
+        # vertical and xblock levels.
+        # This should be removed after Sections and Subsections are
+        # implemented in the openedx-learning repo.
+        # https://github.com/openedx/frontend-app-authoring/issues/1602
+        """
+        return [cls.VERTICAL.value, cls.XBLOCK.value]
+
 
 PublishableVersionWithMapping = namedtuple('PublishableVersionWithMapping', ['publishable_version', 'mapping'])
diff --git a/cms/djangoapps/import_from_modulestore/validators.py b/cms/djangoapps/import_from_modulestore/validators.py
index 4c9308bb7bdc..d71a9e196c58 100644
--- a/cms/djangoapps/import_from_modulestore/validators.py
+++ b/cms/djangoapps/import_from_modulestore/validators.py
@@ -20,5 +20,5 @@ def validate_usage_keys_to_import(usage_keys: list[str | UsageKey]):
 
 
 def validate_composition_level(composition_level):
-    if composition_level not in CompositionLevel.values():
+    if composition_level not in CompositionLevel.supported_levels():
         raise ValueError(f'Invalid composition level: {composition_level}')

From 8cce09bc33aeab6ffecc2a0a1a5269e2d2902ac3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Tue, 22 Apr 2025 18:44:02 +0300
Subject: [PATCH 16/26] fix: comment tests for not yet supported composition
 levels

---
 .../import_from_modulestore/tests/test_helpers.py         | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
index ca566150cca5..a847c05f9df5 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
@@ -87,7 +87,13 @@ def test_import_from_staged_content_block_not_found(self, mocked_process_import)
         self.assertTrue(not self.learning_package.content_set.count())
         mocked_process_import.assert_not_called()
 
-    @ddt.data('chapter', 'sequential', 'vertical')
+    @ddt.data(
+        # TODO: Chapter and sequential will be uncommented in the future
+        # after adding it to the Learning Core.
+        # 'chapter',
+        # 'sequential',
+        'vertical'
+    )
     def test_create_container(self, block_lvl):
         container_to_import = getattr(self, block_lvl)
         block_usage_key_to_import = str(container_to_import.location)

From 91128226a604812858888b6956444748221f6c68 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Wed, 23 Apr 2025 11:05:03 +0300
Subject: [PATCH 17/26] refactor: fix issues after review

---
 cms/djangoapps/import_from_modulestore/api.py |  2 +-
 .../import_from_modulestore/helpers.py        | 24 +++++++++
 .../import_from_modulestore/models.py         |  8 ---
 .../import_from_modulestore/tasks.py          | 49 +++++++------------
 4 files changed, 44 insertions(+), 39 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
index 6d3d503602d6..0106f4a5432d 100644
--- a/cms/djangoapps/import_from_modulestore/api.py
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -33,7 +33,7 @@ def import_staged_content_to_library(
     validate_usage_keys_to_import(usage_ids)
     import_staged_content_to_library_task.apply_async(
         kwargs={
-            'usage_keys_string': usage_ids,
+            'usage_key_strings': usage_ids,
             'import_uuid': import_uuid,
             'learning_package_id': target_learning_package_id,
             'user_id': user_id,
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 80a837ee2bba..243b7447e6fc 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -368,6 +368,30 @@ def _process_staged_content_files(
                 pass  # Content already exists
 
 
+def import_from_staged_content(
+    import_event: Import,
+    usage_key_string: str,
+    target_learning_package: 'LearningPackage',
+    staged_content: 'StagedContent',
+    composition_level: str,
+    override: bool = False,
+) -> list[PublishableVersionWithMapping]:
+    """
+    Import staged content to a library from staged content.
+
+    Returns a list of PublishableVersionWithMappings created during the import.
+    """
+    import_client = ImportClient(
+        import_event,
+        usage_key_string,
+        target_learning_package,
+        staged_content,
+        composition_level,
+        override,
+    )
+    return import_client.import_from_staged_content()
+
+
 def get_or_create_publishable_entity_mapping(usage_key, component) -> tuple[PublishableEntityMapping, bool]:
     """
     Creates a mapping between the source usage key and the target publishable entity.
diff --git a/cms/djangoapps/import_from_modulestore/models.py b/cms/djangoapps/import_from_modulestore/models.py
index 8fd9e46584fe..5b6122749bba 100644
--- a/cms/djangoapps/import_from_modulestore/models.py
+++ b/cms/djangoapps/import_from_modulestore/models.py
@@ -1,7 +1,6 @@
 """
 Models for the course to library import app.
 """
-from typing import Optional
 import uuid as uuid_tools
 
 from django.contrib.auth import get_user_model
@@ -62,13 +61,6 @@ def clean_related_staged_content(self) -> None:
         for staged_content_for_import in self.staged_content_for_import.all():
             staged_content_for_import.staged_content.delete()
 
-    def get_staged_content_by_source_usage_key(self, source_key) -> Optional["StagedContent"]:
-        """
-        Get staged content by source usage key in related to import staged content.
-        """
-        staged_content_for_import = self.staged_content_for_import.filter(source_usage_key=source_key).first()
-        return staged_content_for_import.staged_content if staged_content_for_import else None
-
 
 class PublishableEntityMapping(TimeStampedModel):
     """
diff --git a/cms/djangoapps/import_from_modulestore/tasks.py b/cms/djangoapps/import_from_modulestore/tasks.py
index bce12a004419..bb6a6a4ac999 100644
--- a/cms/djangoapps/import_from_modulestore/tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tasks.py
@@ -13,7 +13,7 @@
 
 from .constants import IMPORT_FROM_MODULESTORE_STAGING_PURPOSE
 from .data import ImportStatus
-from .helpers import get_items_to_import, ImportClient
+from .helpers import get_items_to_import, import_from_staged_content
 from .models import Import, PublishableEntityImport, StagedContentForImport
 from .validators import validate_composition_level
 
@@ -26,11 +26,7 @@ def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
     """
     Save courses to staged content task by sections/chapters.
     """
-    try:
-        import_event = Import.objects.get(uuid=import_uuid)
-    except Import.DoesNotExist:
-        log.info('Import event not found for UUID %s', import_uuid)
-        return
+    import_event = Import.objects.get(uuid=import_uuid)
 
     import_event.clean_related_staged_content()
     import_event.set_status(ImportStatus.STAGING)
@@ -61,7 +57,7 @@ def save_legacy_content_to_staged_content_task(import_uuid: str) -> None:
 @shared_task
 @set_code_owner_attribute
 def import_staged_content_to_library_task(
-    usage_keys_string: list[str],
+    usage_key_strings: list[str],
     import_uuid: str,
     learning_package_id: int,
     user_id: int,
@@ -72,34 +68,27 @@ def import_staged_content_to_library_task(
     Import staged content to a library task.
     """
     validate_composition_level(composition_level)
-    try:
-        import_event = Import.objects.get(uuid=import_uuid, status=ImportStatus.STAGED, user_id=user_id)
-    except Import.DoesNotExist:
-        log.info('Ready import from modulestore not found')
-        return
-    try:
-        target_learning_package = LearningPackage.objects.get(id=learning_package_id)
-    except Import.LearningPackage:
-        log.info('Target learning package not found')
-        return
+
+    import_event = Import.objects.get(uuid=import_uuid, status=ImportStatus.STAGED, user_id=user_id)
+    target_learning_package = LearningPackage.objects.get(id=learning_package_id)
 
     imported_publishable_versions = []
     with authoring_api.bulk_draft_changes_for(learning_package_id=learning_package_id) as change_log:
         try:
-            for usage_key_string in usage_keys_string:
-                if staged_content_item := import_event.get_staged_content_by_source_usage_key(usage_key_string):
-                    import_client = ImportClient(
-                        import_event,
-                        usage_key_string,
-                        target_learning_package,
-                        staged_content_item,
-                        composition_level,
-                        override,
-                    )
-                    imported_publishable_versions.extend(import_client.import_from_staged_content())
-        except Exception as exc:  # pylint: disable=broad-except
+            for usage_key_string in usage_key_strings:
+                staged_content_for_import = import_event.staged_content_for_import.get(source_usage_key=usage_key_string)
+                publishable_versions = import_from_staged_content(
+                    import_event,
+                    usage_key_string,
+                    target_learning_package,
+                    staged_content_for_import.staged_content,
+                    composition_level,
+                    override,
+                )
+                imported_publishable_versions.extend(publishable_versions)
+        except:  # pylint: disable=bare-except
             import_event.set_status(ImportStatus.IMPORTING_FAILED)
-            raise exc from exc  # TODO: retest raise and describe change_log commitment on Exception
+            raise
 
     import_event.set_status(ImportStatus.IMPORTED)
     for imported_component_version in imported_publishable_versions:

From 5f6a1e5c2c001ef7694c36f5d4768c35b27782c2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Wed, 23 Apr 2025 11:07:05 +0300
Subject: [PATCH 18/26] feat: adding support for importing sections and
 subsections

---
 .../import_from_modulestore/data.py           | 14 -------------
 .../import_from_modulestore/helpers.py        | 21 ++++++++-----------
 .../import_from_modulestore/validators.py     |  2 +-
 3 files changed, 10 insertions(+), 27 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/data.py b/cms/djangoapps/import_from_modulestore/data.py
index e405713dead9..d600060ef522 100644
--- a/cms/djangoapps/import_from_modulestore/data.py
+++ b/cms/djangoapps/import_from_modulestore/data.py
@@ -49,19 +49,5 @@ def values(cls):
         """
         return [composition_level.value for composition_level in cls]
 
-    @classmethod
-    def supported_levels(cls):
-        """
-        Returns all supported levels of composition levels.
-
-        # TEMPORARY: This is a temporary solution to support the
-        # import from modulestore to learning core for the
-        # vertical and xblock levels.
-        # This should be removed after Sections and Subsections are
-        # implemented in the openedx-learning repo.
-        # https://github.com/openedx/frontend-app-authoring/issues/1602
-        """
-        return [cls.VERTICAL.value, cls.XBLOCK.value]
-
 
 PublishableVersionWithMapping = namedtuple('PublishableVersionWithMapping', ['publishable_version', 'mapping'])
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 243b7447e6fc..8393c5bc7f6c 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -2,6 +2,7 @@
 Helper functions for importing course content into a library.
 """
 from datetime import datetime, timezone
+from functools import partial
 import logging
 import mimetypes
 import os
@@ -37,20 +38,18 @@ class ImportClient:
     specified composition level.
     """
 
+    # The create functions have different kwarg names for the child list,
+    # so we need to use partial to set the child list to empty.
     CONTAINER_CREATORS_MAP = {
-        # Sequential- and Chapter-level composition to be added in the future as part of
-        # https://github.com/openedx/frontend-app-authoring/issues/1602
-        # 'chapter': authoring_api.create_unit_and_version,  # TODO: replace with create_module_and_version
-        # 'sequential': authoring_api.create_unit_and_version,  # TODO: replace with create_section_and_version
-        'vertical': authoring_api.create_unit_and_version,
+        'chapter': partial(authoring_api.create_section_and_version, subsections=[]),
+        'sequential': partial(authoring_api.create_subsection_and_version, units=[]),
+        'vertical': partial(authoring_api.create_unit_and_version, components=[]),
     }
 
     CONTAINER_OVERRIDERS_MAP = {
-        # Sequential- and Chapter-level composition to be added in the future as part of
-        # https://github.com/openedx/frontend-app-authoring/issues/1602
-        # 'chapter': authoring_api.create_next_unit_version,  # TODO: replace with create_next_module_version
-        # 'sequential': authoring_api.create_next_unit_version,  # TODO: replace with create_next_section_version
-        'vertical': authoring_api.create_next_unit_version,
+        'chapter': partial(authoring_api.create_next_section_version, subsections=[]),
+        'sequential': partial(authoring_api.create_next_subsection_version, units=[]),
+        'vertical': partial(authoring_api.create_next_unit_version, components=[]),
     }
 
     def __init__(
@@ -204,7 +203,6 @@ def get_or_create_container(
             container_version = container_override_func(
                 container_version.container,
                 title=display_name or f"New {container_type}",
-                components=[],
                 created=datetime.now(tz=timezone.utc),
                 created_by=self.import_event.user_id,
             )
@@ -213,7 +211,6 @@ def get_or_create_container(
                 self.learning_package.id,
                 key=key or secrets.token_hex(16),
                 title=display_name or f"New {container_type}",
-                components=[],
                 created=datetime.now(tz=timezone.utc),
                 created_by=self.import_event.user_id,
             )
diff --git a/cms/djangoapps/import_from_modulestore/validators.py b/cms/djangoapps/import_from_modulestore/validators.py
index d71a9e196c58..4c9308bb7bdc 100644
--- a/cms/djangoapps/import_from_modulestore/validators.py
+++ b/cms/djangoapps/import_from_modulestore/validators.py
@@ -20,5 +20,5 @@ def validate_usage_keys_to_import(usage_keys: list[str | UsageKey]):
 
 
 def validate_composition_level(composition_level):
-    if composition_level not in CompositionLevel.supported_levels():
+    if composition_level not in CompositionLevel.values():
         raise ValueError(f'Invalid composition level: {composition_level}')

From 852a243cf24c47760520e2a5e0d54bb3793c8ac0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Wed, 23 Apr 2025 11:07:34 +0300
Subject: [PATCH 19/26] test: fix tests after refactoring

---
 .../import_from_modulestore/tests/test_api.py |  2 +-
 .../tests/test_helpers.py                     | 72 +++++++++++++------
 .../tests/test_tasks.py                       | 26 +++----
 3 files changed, 66 insertions(+), 34 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/tests/test_api.py b/cms/djangoapps/import_from_modulestore/tests/test_api.py
index 02cefcb19a36..62fe2e4159a9 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_api.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_api.py
@@ -73,7 +73,7 @@ def test_import_staged_content_to_library(self):
 
         import_staged_content_to_library_task_mock.apply_async.assert_called_once_with(
             kwargs={
-                "usage_keys_string": usage_ids,
+                "usage_key_strings": usage_ids,
                 "import_uuid": import_event.uuid,
                 "learning_package_id": self.library.learning_package.id,
                 "user_id": import_event.user.id,
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
index a847c05f9df5..1d2ce26867aa 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_helpers.py
@@ -56,7 +56,10 @@ def setUp(self):
 
     def test_import_from_staged_content(self):
         expected_imported_xblocks = [self.video, self.problem]
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
+        staged_content = staged_content_for_import.staged_content
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
@@ -72,7 +75,10 @@ def test_import_from_staged_content(self):
 
     @patch('cms.djangoapps.import_from_modulestore.helpers.ImportClient._process_import')
     def test_import_from_staged_content_block_not_found(self, mocked_process_import):
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
+        staged_content = staged_content_for_import.staged_content
         import_client = ImportClient(
             import_event=self.import_event,
             staged_content=staged_content,
@@ -88,19 +94,19 @@ def test_import_from_staged_content_block_not_found(self, mocked_process_import)
         mocked_process_import.assert_not_called()
 
     @ddt.data(
-        # TODO: Chapter and sequential will be uncommented in the future
-        # after adding it to the Learning Core.
-        # 'chapter',
-        # 'sequential',
+        'chapter',
+        'sequential',
         'vertical'
     )
     def test_create_container(self, block_lvl):
         container_to_import = getattr(self, block_lvl)
         block_usage_key_to_import = str(container_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(block_usage_key_to_import)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
         import_client = ImportClient(
             import_event=self.import_event,
-            staged_content=staged_content,
+            staged_content=staged_content_for_import.staged_content,
             target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
@@ -117,10 +123,12 @@ def test_create_container(self, block_lvl):
 
     def test_create_container_with_xblock(self):
         block_usage_key_to_import = str(self.problem.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(block_usage_key_to_import)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
         import_client = ImportClient(
             import_event=self.import_event,
-            staged_content=staged_content,
+            staged_content=staged_content_for_import.staged_content,
             target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
@@ -138,7 +146,10 @@ def test_create_container_with_xblock(self):
     def test_process_import_with_complicated_blocks(self, block_lvl):
         container_to_import = getattr(self, block_lvl)
         block_usage_key_to_import = str(container_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
+        staged_content = staged_content_for_import.staged_content
         expected_imported_xblocks = [self.problem, self.video]
 
         import_client = ImportClient(
@@ -160,11 +171,13 @@ def test_process_import_with_complicated_blocks(self, block_lvl):
     def test_process_import_with_simple_blocks(self, block_type_to_import):
         block_to_import = getattr(self, block_type_to_import)
         block_usage_key_to_import = str(block_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
         expected_imported_xblocks = [block_to_import]
         import_client = ImportClient(
             import_event=self.import_event,
-            staged_content=staged_content,
+            staged_content=staged_content_for_import.staged_content,
             target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
@@ -182,11 +195,13 @@ def test_process_import_with_simple_blocks(self, block_type_to_import):
     def test_process_import_with_override(self, override):
         block_to_import = self.problem
         block_usage_key_to_import = str(block_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
 
         import_client = ImportClient(
             import_event=self.import_event,
-            staged_content=staged_content,
+            staged_content=staged_content_for_import.staged_content,
             target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='xblock',
@@ -200,7 +215,11 @@ def test_process_import_with_override(self, override):
 
         with self.captureOnCommitCallbacks(execute=True):
             new_import_event = api.stage_content_for_import(source_key=self.course.id, user_id=self.user.id)
-        new_staged_content = new_import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+
+        staged_content_for_import = new_import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
+        new_staged_content = staged_content_for_import.staged_content
         import_client = ImportClient(
             import_event=new_import_event,
             staged_content=new_staged_content,
@@ -234,7 +253,10 @@ def test_process_import_with_override(self, override):
     def test_container_override(self, mock_authoring_api):
         container_to_import = self.vertical
         block_usage_key_to_import = str(container_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
+        staged_content = staged_content_for_import.staged_content
 
         import_client = ImportClient(
             import_event=self.import_event,
@@ -283,7 +305,10 @@ def test_composition_levels(self, composition_level):
 
         container_to_import = self.vertical
         block_usage_key_to_import = str(container_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
+        staged_content = staged_content_for_import.staged_content
 
         import_client = ImportClient(
             import_event=self.import_event,
@@ -304,7 +329,10 @@ def test_composition_levels(self, composition_level):
     def test_process_staged_content_files(self, mock_content_staging_api):
         block_to_import = self.problem
         block_usage_key_to_import = str(block_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
+        staged_content = staged_content_for_import.staged_content
 
         import_client = ImportClient(
             import_event=self.import_event,
@@ -339,11 +367,13 @@ def test_process_staged_content_files(self, mock_content_staging_api):
     def test_update_container_components(self):
         container_to_import = self.vertical
         block_usage_key_to_import = str(container_to_import.location)
-        staged_content = self.import_event.get_staged_content_by_source_usage_key(self.chapter.location)
+        staged_content_for_import = self.import_event.staged_content_for_import.get(
+            source_usage_key=self.chapter.location
+        )
 
         import_client = ImportClient(
             import_event=self.import_event,
-            staged_content=staged_content,
+            staged_content=staged_content_for_import.staged_content,
             target_learning_package=self.learning_package,
             block_usage_key_to_import=block_usage_key_to_import,
             composition_level='container',
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
index cf6ae7471f41..3069f8caa9c8 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
@@ -1,6 +1,7 @@
 """
 Tests for tasks in import_from_modulestore app.
 """
+from django.core.exceptions import ObjectDoesNotExist
 from organizations.models import Organization
 from openedx_learning.api.authoring_models import LearningPackage
 from unittest.mock import patch
@@ -117,21 +118,22 @@ def test_import_staged_content_to_library_task(self):
         self.assertEqual(library_learning_package.content_set.count(), len(expected_imported_xblocks))
         self.assertEqual(self.import_event.publishableentityimport_set.count(), len(expected_imported_xblocks))
 
-    @patch('cms.djangoapps.import_from_modulestore.tasks.ImportClient')
-    def test_import_library_block_not_found(self, mock_import_client):
+    @patch('cms.djangoapps.import_from_modulestore.tasks.import_from_staged_content')
+    def test_import_library_block_not_found(self, mock_import_from_staged_content):
         """ Test that if a block is not found in the staged content, it is not imported. """
         non_existent_usage_ids = ['block-v1:edX+Demo+2023+type@vertical+block@12345']
         save_legacy_content_to_staged_content_task(self.import_event.uuid)
-
-        import_staged_content_to_library_task(
-            non_existent_usage_ids,
-            str(self.import_event.uuid),
-            self.content_library.learning_package.id,
-            self.user.id,
-            'xblock',
-            override=True,
-        )
-        mock_import_client.assert_not_called()
+        with self.allow_transaction_exception():
+            with self.assertRaises(ObjectDoesNotExist):
+                import_staged_content_to_library_task(
+                    non_existent_usage_ids,
+                    str(self.import_event.uuid),
+                    self.content_library.learning_package.id,
+                    self.user.id,
+                    'xblock',
+                    override=True,
+                )
+                mock_import_from_staged_content.assert_not_called()
 
     def test_cannot_import_staged_content_twice(self):
         """

From 9b96363051bf197c88157bd2756d8627b3d58acf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Wed, 23 Apr 2025 11:23:29 +0300
Subject: [PATCH 20/26] style: fix naming and add type hints

---
 .../import_from_modulestore/helpers.py        | 28 ++++++++++---------
 .../import_from_modulestore/tasks.py          |  4 ++-
 2 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 8393c5bc7f6c..6bdd3ffbf778 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -79,7 +79,7 @@ def import_from_staged_content(self) -> list[PublishableVersionWithMapping]:
         """
         node = etree.fromstring(self.staged_content.olx, parser=parser)
         usage_key = UsageKey.from_string(self.block_usage_key_to_import)
-        block_to_import = get_block_to_import(node, usage_key)
+        block_to_import = get_node_for_usage_key(node, usage_key)
         if block_to_import is None:
             return []
 
@@ -389,7 +389,10 @@ def import_from_staged_content(
     return import_client.import_from_staged_content()
 
 
-def get_or_create_publishable_entity_mapping(usage_key, component) -> tuple[PublishableEntityMapping, bool]:
+def get_or_create_publishable_entity_mapping(
+        usage_key: UsageKey,
+        component: 'Component' | 'Container'
+) -> tuple[PublishableEntityMapping, bool]:
     """
     Creates a mapping between the source usage key and the target publishable entity.
     """
@@ -404,28 +407,27 @@ def get_or_create_publishable_entity_mapping(usage_key, component) -> tuple[Publ
     )
 
 
-def get_usage_key_string_from_staged_content(staged_content, block_id):
+def get_usage_key_string_from_staged_content(staged_content: 'StagedContent', block_id: str) -> str | None:
     """
     Get the usage ID from a staged content by block ID.
     """
     return next((block_usage_id for block_usage_id in staged_content.tags if block_usage_id.endswith(block_id)), None)
 
 
-def get_block_to_import(node, usage_key):
+def get_node_for_usage_key(node: etree._Element, usage_key: UsageKey) -> etree._Element:
     """
-    Get the block to import from a node.
+    Get the node in an XML tree which matches to the usage key.
     """
-
     if node.get('url_name') == usage_key.block_id:
         return node
 
     for child in node.getchildren():
-        found = get_block_to_import(child, usage_key)
+        found = get_node_for_usage_key(child, usage_key)
         if found is not None:
             return found
 
 
-def get_items_to_import(import_event):
+def get_items_to_import(import_event: Import) -> list['XBlock']:
     """
     Collect items to import from a course.
     """
@@ -441,17 +443,17 @@ def get_items_to_import(import_event):
     return items_to_import
 
 
-def cancel_incomplete_old_imports(instance):
+def cancel_incomplete_old_imports(import_event: Import) -> None:
     """
     Cancel any incomplete imports that have the same target as the current import.
 
     When a new import is created, we want to cancel any other incomplete user imports that have the same target.
     """
     incomplete_user_imports_with_same_target = Import.objects.filter(
-        user=instance.user,
-        target_change=instance.target_change,
-        source_key=instance.source_key,
+        user=import_event.user,
+        target_change=import_event.target_change,
+        source_key=import_event.source_key,
         staged_content_for_import__isnull=False
-    ).exclude(uuid=instance.uuid)
+    ).exclude(uuid=import_event.uuid)
     for incomplete_import in incomplete_user_imports_with_same_target:
         incomplete_import.set_status(ImportStatus.CANCELED)
diff --git a/cms/djangoapps/import_from_modulestore/tasks.py b/cms/djangoapps/import_from_modulestore/tasks.py
index bb6a6a4ac999..4644b29e4904 100644
--- a/cms/djangoapps/import_from_modulestore/tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tasks.py
@@ -76,7 +76,9 @@ def import_staged_content_to_library_task(
     with authoring_api.bulk_draft_changes_for(learning_package_id=learning_package_id) as change_log:
         try:
             for usage_key_string in usage_key_strings:
-                staged_content_for_import = import_event.staged_content_for_import.get(source_usage_key=usage_key_string)
+                staged_content_for_import = import_event.staged_content_for_import.get(
+                    source_usage_key=usage_key_string
+                )
                 publishable_versions = import_from_staged_content(
                     import_event,
                     usage_key_string,

From 227230b0df26fa1cbfb9d849575631ff1f02f41d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Wed, 23 Apr 2025 11:23:43 +0300
Subject: [PATCH 21/26] chore: add cms/djangoapps/import_from_modulestore to
 mypy.ini

---
 mypy.ini | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mypy.ini b/mypy.ini
index 40f58ff5c411..83255c1a5af1 100644
--- a/mypy.ini
+++ b/mypy.ini
@@ -8,6 +8,7 @@ plugins =
 files =
     cms/lib/xblock/upstream_sync.py,
     cms/djangoapps/contentstore/rest_api/v2/views/downstreams.py,
+    cms/djangoapps/import_from_modulestore,
     openedx/core/djangoapps/content/learning_sequences,
     # FIXME: need to solve type issues and add 'search' app here:
     # openedx/core/djangoapps/content/search,

From 2761d16df10553e1be0a51505839531cd83598af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Wed, 23 Apr 2025 12:02:35 +0300
Subject: [PATCH 22/26] refactor: refactor Composition Levels

---
 cms/djangoapps/import_from_modulestore/data.py  | 17 +++++++++--------
 .../import_from_modulestore/helpers.py          | 15 ++++++---------
 .../import_from_modulestore/tests/test_tasks.py |  6 +++---
 3 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/data.py b/cms/djangoapps/import_from_modulestore/data.py
index d600060ef522..998ea8dfc745 100644
--- a/cms/djangoapps/import_from_modulestore/data.py
+++ b/cms/djangoapps/import_from_modulestore/data.py
@@ -3,6 +3,7 @@
 """
 from collections import namedtuple
 from enum import Enum
+from openedx.core.djangoapps.content_libraries import api as content_libraries_api
 
 from django.db.models import TextChoices
 from django.utils.translation import gettext_lazy as _
@@ -32,14 +33,14 @@ class CompositionLevel(Enum):
     levels for easier processing.
     """
 
-    CHAPTER = 'chapter'
-    SEQUENTIAL = 'sequential'
-    VERTICAL = 'vertical'
-    XBLOCK = 'xblock'
-    COMPLEX_LEVELS = [
-        VERTICAL,
-        SEQUENTIAL,
-        CHAPTER,
+    CHAPTER = content_libraries_api.ContainerType.Section
+    SEQUENTIAL = content_libraries_api.ContainerType.Subsection
+    VERTICAL = content_libraries_api.ContainerType.Unit
+    COMPONENT = 'component'
+    OLX_COMPLEX_LEVELS = [
+        VERTICAL.olx_tag,
+        SEQUENTIAL.olx_tag,
+        CHAPTER.olx_tag,
     ]
 
     @classmethod
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 6bdd3ffbf778..7bf676d92e93 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -96,7 +96,7 @@ def _process_import(self, usage_key_string, block_to_import) -> list[Publishable
         usage_key = UsageKey.from_string(usage_key_string)
         result = []
 
-        if block_to_import.tag not in CompositionLevel.COMPLEX_LEVELS.value:
+        if block_to_import.tag not in CompositionLevel.OLX_COMPLEX_LEVELS.value:
             return self._import_simple_block(block_to_import, usage_key)
 
         for child in block_to_import.getchildren():
@@ -108,7 +108,7 @@ def _process_import(self, usage_key_string, block_to_import) -> list[Publishable
 
             result.extend(self._import_child_block(child, child_usage_key_string))
 
-        if self.composition_level == CompositionLevel.XBLOCK.value:
+        if self.composition_level == CompositionLevel.COMPONENT.value:
             return [
                 publishable_version_with_mapping for publishable_version_with_mapping in result
                 if not isinstance(publishable_version_with_mapping.publishable_version, ContainerVersion)
@@ -133,7 +133,7 @@ def _import_child_block(self, child, child_usage_key_string):
         delegates the import process to the appropriate helper method.
         """
         child_usage_key = UsageKey.from_string(child_usage_key_string)
-        if child.tag in CompositionLevel.COMPLEX_LEVELS.value:
+        if child.tag in CompositionLevel.OLX_COMPLEX_LEVELS.value:
             return self._import_complicated_child(child, child_usage_key_string)
         else:
             return self._import_simple_block(child, child_usage_key)
@@ -169,7 +169,7 @@ def _should_create_container(self, container_type: str) -> bool:
 
         Container type should be at a lower level than the current composition level.
         """
-        composition_hierarchy = CompositionLevel.COMPLEX_LEVELS.value
+        composition_hierarchy = CompositionLevel.OLX_COMPLEX_LEVELS.value
         return (
             container_type in composition_hierarchy and
             self.composition_level in composition_hierarchy and
@@ -389,10 +389,7 @@ def import_from_staged_content(
     return import_client.import_from_staged_content()
 
 
-def get_or_create_publishable_entity_mapping(
-        usage_key: UsageKey,
-        component: 'Component' | 'Container'
-) -> tuple[PublishableEntityMapping, bool]:
+def get_or_create_publishable_entity_mapping(usage_key, component) -> tuple[PublishableEntityMapping, bool]:
     """
     Creates a mapping between the source usage key and the target publishable entity.
     """
@@ -418,7 +415,7 @@ def get_node_for_usage_key(node: etree._Element, usage_key: UsageKey) -> etree._
     """
     Get the node in an XML tree which matches to the usage key.
     """
-    if node.get('url_name') == usage_key.block_id:
+    if node.tag == usage_key.block_type and node.get('url_name') == usage_key.block_id:
         return node
 
     for child in node.getchildren():
diff --git a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
index 3069f8caa9c8..8c24fa95c1cc 100644
--- a/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
+++ b/cms/djangoapps/import_from_modulestore/tests/test_tasks.py
@@ -104,7 +104,7 @@ def test_import_staged_content_to_library_task(self):
             self.import_event.uuid,
             self.content_library.learning_package.id,
             self.user.id,
-            'xblock',
+            'component',
             override=True
         )
 
@@ -130,7 +130,7 @@ def test_import_library_block_not_found(self, mock_import_from_staged_content):
                     str(self.import_event.uuid),
                     self.content_library.learning_package.id,
                     self.user.id,
-                    'xblock',
+                    'component',
                     override=True,
                 )
                 mock_import_from_staged_content.assert_not_called()
@@ -153,7 +153,7 @@ def test_cannot_import_staged_content_twice(self):
             str(self.import_event.uuid),
             self.content_library.learning_package.id,
             self.user.id,
-            'xblock',
+            'component',
             override=True,
         )
 

From a5595f26ca75b28a8479f75323046317d5f0b6bd Mon Sep 17 00:00:00 2001
From: Andrii <andrii.hantkovskyi@raccoongang.com>
Date: Wed, 23 Apr 2025 15:31:12 +0300
Subject: [PATCH 23/26] refactor: improve static typization to fix mypy errors

---
 cms/djangoapps/import_from_modulestore/api.py |  6 +++--
 .../import_from_modulestore/helpers.py        | 26 +++++++++++++------
 .../import_from_modulestore/validators.py     |  4 ++-
 3 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/api.py b/cms/djangoapps/import_from_modulestore/api.py
index 0106f4a5432d..7f8dc16b76cb 100644
--- a/cms/djangoapps/import_from_modulestore/api.py
+++ b/cms/djangoapps/import_from_modulestore/api.py
@@ -1,7 +1,9 @@
 """
 API for course to library import.
 """
-from opaque_keys.edx.keys import LearningContextKey
+from typing import Sequence
+
+from opaque_keys.edx.keys import LearningContextKey, UsageKey
 
 from .helpers import cancel_incomplete_old_imports
 from .models import Import as _Import
@@ -20,7 +22,7 @@ def stage_content_for_import(source_key: LearningContextKey, user_id: int) -> _I
 
 
 def import_staged_content_to_library(
-    usage_ids: list[str],
+    usage_ids: Sequence[str | UsageKey],
     import_uuid: str,
     target_learning_package_id: int,
     user_id: int,
diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 7bf676d92e93..b2898ac85f1e 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -7,6 +7,7 @@
 import mimetypes
 import os
 import secrets
+from typing import TYPE_CHECKING
 
 from django.db import transaction
 from django.db.utils import IntegrityError
@@ -24,6 +25,12 @@
 from .data import CompositionLevel, ImportStatus, PublishableVersionWithMapping
 from .models import Import, PublishableEntityMapping
 
+if TYPE_CHECKING:
+    from openedx_learning.apps.authoring_models import LearningPackage
+    from xblock.core import XBlock
+
+    from openedx.core.djangoapps.content_staging.models import StagedContent
+
 
 log = logging.getLogger(__name__)
 parser = etree.XMLParser(strip_cdata=False)
@@ -40,13 +47,13 @@ class ImportClient:
 
     # The create functions have different kwarg names for the child list,
     # so we need to use partial to set the child list to empty.
-    CONTAINER_CREATORS_MAP = {
+    CONTAINER_CREATORS_MAP: dict[str, partial] = {
         'chapter': partial(authoring_api.create_section_and_version, subsections=[]),
         'sequential': partial(authoring_api.create_subsection_and_version, units=[]),
         'vertical': partial(authoring_api.create_unit_and_version, components=[]),
     }
 
-    CONTAINER_OVERRIDERS_MAP = {
+    CONTAINER_OVERRIDERS_MAP: dict[str, partial] = {
         'chapter': partial(authoring_api.create_next_section_version, subsections=[]),
         'sequential': partial(authoring_api.create_next_subsection_version, units=[]),
         'vertical': partial(authoring_api.create_next_unit_version, components=[]),
@@ -189,9 +196,10 @@ def get_or_create_container(
         Creates a container (e.g., chapter, sequential, vertical) in the
         content library.
         """
-        container_creator_func = self.CONTAINER_CREATORS_MAP.get(container_type)
-        container_override_func = self.CONTAINER_OVERRIDERS_MAP.get(container_type)
-        if not all((container_creator_func, container_override_func)):
+        try:
+            container_creator_func = self.CONTAINER_CREATORS_MAP[container_type]
+            container_override_func = self.CONTAINER_OVERRIDERS_MAP[container_type]
+        except KeyError:
             raise ValueError(f"Unknown container type: {container_type}")
 
         try:
@@ -258,7 +266,7 @@ def _create_block_in_library(self, block_to_import, usage_key) -> PublishableVer
             if does_component_exist:
                 if not self.override:
                     log.info(f"Component {usage_key.block_id} already exists in library {self.library_key}, skipping.")
-                    return
+                    return None
                 else:
                     component_version = self._handle_component_override(usage_key, etree.tostring(block_to_import))
             else:
@@ -270,7 +278,7 @@ def _create_block_in_library(self, block_to_import, usage_key) -> PublishableVer
                     )
                 except api.IncompatibleTypesError as e:
                     log.error(f"Error validating block {usage_key} for library {self.library_key}: {e}")
-                    return
+                    return None
 
                 authoring_api.create_component(
                     self.learning_package.id,
@@ -408,6 +416,8 @@ def get_usage_key_string_from_staged_content(staged_content: 'StagedContent', bl
     """
     Get the usage ID from a staged content by block ID.
     """
+    if staged_content.tags is None:
+        return None
     return next((block_usage_id for block_usage_id in staged_content.tags if block_usage_id.endswith(block_id)), None)
 
 
@@ -428,7 +438,7 @@ def get_items_to_import(import_event: Import) -> list['XBlock']:
     """
     Collect items to import from a course.
     """
-    items_to_import = []
+    items_to_import: list['XBlock'] = []
     if isinstance(import_event.source_key, CourseLocator):
         items_to_import.extend(
             modulestore().get_items(import_event.source_key, qualifiers={"category": "chapter"}) or []
diff --git a/cms/djangoapps/import_from_modulestore/validators.py b/cms/djangoapps/import_from_modulestore/validators.py
index 4c9308bb7bdc..ecf0c72e08e8 100644
--- a/cms/djangoapps/import_from_modulestore/validators.py
+++ b/cms/djangoapps/import_from_modulestore/validators.py
@@ -1,12 +1,14 @@
 """
 Validators for the import_from_modulestore app.
 """
+from typing import Sequence
+
 from opaque_keys.edx.keys import UsageKey
 
 from .data import CompositionLevel
 
 
-def validate_usage_keys_to_import(usage_keys: list[str | UsageKey]):
+def validate_usage_keys_to_import(usage_keys: Sequence[str | UsageKey]):
     """
     Validate the usage keys to import.
 

From 51658aa93c4b395bf6023e016ac427dc772dcfed Mon Sep 17 00:00:00 2001
From: Andrii <andrii.hantkovskyi@raccoongang.com>
Date: Wed, 23 Apr 2025 15:38:40 +0300
Subject: [PATCH 24/26] refactor: fix StagedContent import to prevent lint
 error

---
 cms/djangoapps/import_from_modulestore/helpers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index b2898ac85f1e..2e5e8f3eae5c 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -29,7 +29,7 @@
     from openedx_learning.apps.authoring_models import LearningPackage
     from xblock.core import XBlock
 
-    from openedx.core.djangoapps.content_staging.models import StagedContent
+    from openedx.core.djangoapps.content_staging.api import _StagedContent as StagedContent
 
 
 log = logging.getLogger(__name__)

From be631da37977706fcb89655751cbdd19fbef331d Mon Sep 17 00:00:00 2001
From: Andrii <andrii.hantkovskyi@raccoongang.com>
Date: Wed, 23 Apr 2025 15:52:05 +0300
Subject: [PATCH 25/26] refactor: fix pylint error for error raising

---
 cms/djangoapps/import_from_modulestore/helpers.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 2e5e8f3eae5c..4c82c7eb031f 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -199,8 +199,8 @@ def get_or_create_container(
         try:
             container_creator_func = self.CONTAINER_CREATORS_MAP[container_type]
             container_override_func = self.CONTAINER_OVERRIDERS_MAP[container_type]
-        except KeyError:
-            raise ValueError(f"Unknown container type: {container_type}")
+        except KeyError as exc:
+            raise ValueError(f"Unknown container type: {container_type}") from exc
 
         try:
             container_version = self.content_library.learning_package.publishable_entities.get(key=key)

From c49cdaeb0b6c75524fb6717c4b58dc465023ec44 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=86=D0=B2=D0=B0=D0=BD=20=D0=9D=D1=94=D0=B4=D1=94=D0=BB?=
 =?UTF-8?q?=D1=8C=D0=BD=D1=96=D1=86=D0=B5=D0=B2?=
 <ivan.niedielnitsev@raccoongang.com>
Date: Wed, 23 Apr 2025 17:39:10 +0300
Subject: [PATCH 26/26] refactor: improve Import client container mapps

---
 cms/djangoapps/import_from_modulestore/helpers.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/cms/djangoapps/import_from_modulestore/helpers.py b/cms/djangoapps/import_from_modulestore/helpers.py
index 4c82c7eb031f..e540e0ff3dba 100644
--- a/cms/djangoapps/import_from_modulestore/helpers.py
+++ b/cms/djangoapps/import_from_modulestore/helpers.py
@@ -48,15 +48,15 @@ class ImportClient:
     # The create functions have different kwarg names for the child list,
     # so we need to use partial to set the child list to empty.
     CONTAINER_CREATORS_MAP: dict[str, partial] = {
-        'chapter': partial(authoring_api.create_section_and_version, subsections=[]),
-        'sequential': partial(authoring_api.create_subsection_and_version, units=[]),
-        'vertical': partial(authoring_api.create_unit_and_version, components=[]),
+        api.ContainerType.Section.olx_tag: partial(authoring_api.create_section_and_version, subsections=[]),
+        api.ContainerType.Subsection.olx_tag: partial(authoring_api.create_subsection_and_version, units=[]),
+        api.ContainerType.Unit.olx_tag: partial(authoring_api.create_unit_and_version, components=[]),
     }
 
     CONTAINER_OVERRIDERS_MAP: dict[str, partial] = {
-        'chapter': partial(authoring_api.create_next_section_version, subsections=[]),
-        'sequential': partial(authoring_api.create_next_subsection_version, units=[]),
-        'vertical': partial(authoring_api.create_next_unit_version, components=[]),
+        api.ContainerType.Section.olx_tag: partial(authoring_api.create_next_section_version, subsections=[]),
+        api.ContainerType.Subsection.olx_tag: partial(authoring_api.create_next_subsection_version, units=[]),
+        api.ContainerType.Unit.olx_tag: partial(authoring_api.create_next_unit_version, components=[]),
     }
 
     def __init__(