Creates voiceover migration job

core/domain/voiceover_domain.py

@@ -24,7 +24,7 @@
 from core import utils
 from core.domain import state_domain
 
-from typing import Dict, Tuple, TypedDict
+from typing import Dict, Optional, Tuple, TypedDict
 
 
 class EntityVoiceoversDict(TypedDict):
@@ -34,7 +34,8 @@ class EntityVoiceoversDict(TypedDict):
     entity_type: str
     entity_version: int
     language_accent_code: str
-    voiceovers: Dict[str, Dict[str, state_domain.VoiceoverDict]]
+    voiceovers_mapping: Dict[str, Dict[
+        feconf.VoiceoverType.value, Optional[state_domain.VoiceoverDict]]]
 
 
 ContentIdToVoiceoverMappingType = Dict[
@@ -55,8 +56,8 @@ class EntityVoiceovers:
         entity_version: str. The version of the corresponding entity.
         language_accent_code: str. The language-accent code in which the
             voiceover is stored.
-        voiceovers: dict(str, dict(VoiceoverType, VoiceoverDict)). A dict
-            containing content IDs as keys and nested dicts as values.
+        voiceovers_mapping: dict(str, dict(VoiceoverType, VoiceoverDict)). A
+            dict containing content IDs as keys and nested dicts as values.
             Each nested dict contains VoiceoverType as keys and VoiceoverDict
             as values.
     """
@@ -67,8 +68,8 @@ def __init__(
         entity_type: str,
         entity_version: int,
         language_accent_code: str,
-        voiceovers: Dict[str, Dict[
-            feconf.VoiceoverType, state_domain.Voiceover]]
+        voiceovers_mapping: Dict[str, Dict[
+            feconf.VoiceoverType, Optional[state_domain.Voiceover]]]
     ) -> None:
         """Constructs an EntityVoiceovers domain object.
 
@@ -78,16 +79,16 @@ def __init__(
             entity_version: int. The version of the entity.
             language_accent_code: str. The language-accent code of the
                 given voiceover.
-            voiceovers: dict(str, dict(VoiceoverType, VoiceoverDict)). A dict
-                containing content IDs as keys and nested dicts as values.
+            voiceovers_mapping: dict(str, dict(VoiceoverType, VoiceoverDict)). A
+                dict containing content IDs as keys and nested dicts as values.
                 Each nested dict contains VoiceoverType as keys and
                 VoiceoverDict as values.
         """
         self.entity_id = entity_id
         self.entity_type = entity_type
         self.entity_version = entity_version
         self.language_accent_code = language_accent_code
-        self.voiceovers = voiceovers
+        self.voiceovers_mapping = voiceovers_mapping
 
     def to_dict(self) -> EntityVoiceoversDict:
         """Returns the dict representation of the EntityVoiceovers object.
@@ -96,19 +97,26 @@ def to_dict(self) -> EntityVoiceoversDict:
             EntityVoiceoversDict. The dict representation of the
             EntityVoiceovers object.
         """
-        voiceovers_dict = {}
-        for content_id, voiceover_type_to_voiceover in self.voiceovers.items():
-            voiceovers_dict[content_id] = {
-                voiceover_type.value: voiceover_type_to_voiceover[
-                    voiceover_type].to_dict()
-                for voiceover_type in feconf.VoiceoverType
-            }
+        content_id_to_voiceovers_dict: Dict[str, Dict[
+            feconf.VoiceoverType.value, Optional[state_domain.VoiceoverDict]]
+        ] = {}
+
+        for content_id, voiceover_type_to_voiceover in (
+                self.voiceovers_mapping.items()):
+            content_id_to_voiceovers_dict[content_id] = {}
+            for voiceover_type in feconf.VoiceoverType:
+                voiceover = voiceover_type_to_voiceover[voiceover_type]
+                voiceover_dict = (
+                    None if voiceover is None else voiceover.to_dict())
+
+                content_id_to_voiceovers_dict[content_id][
+                    voiceover_type.value] = voiceover_dict
         return {
             'entity_id': self.entity_id,
             'entity_type': self.entity_type,
             'entity_version': self.entity_version,
             'language_accent_code': self.language_accent_code,
-            'voiceovers': voiceovers_dict
+            'voiceovers_mapping': content_id_to_voiceovers_dict
         }
 
     @classmethod
@@ -125,14 +133,21 @@ def from_dict(
             EntityVoiceovers. The EntityVoiceovers instance created using the
             given dict.
         """
-        content_id_to_voiceovers = {}
+        content_id_to_voiceovers: Dict[str, Dict[
+            feconf.VoiceoverType, Optional[state_domain.Voiceover]]] = {}
         for content_id, voiceover_type_to_voiceover_dict in (
-                entity_voiceovers_dict['voiceovers'].items()):
-            content_id_to_voiceovers[content_id] = {
-                voiceover_type: state_domain.Voiceover.from_dict(
-                    voiceover_type_to_voiceover_dict[voiceover_type.value])
-                for voiceover_type in feconf.VoiceoverType
-            }
+                entity_voiceovers_dict['voiceovers_mapping'].items()):
+            content_id_to_voiceovers[content_id] = {}
+            for voiceover_type in feconf.VoiceoverType:
+                voiceover_dict = voiceover_type_to_voiceover_dict[
+                    voiceover_type.value]
+                voiceover = (
+                    None if voiceover_dict is None
+                    else state_domain.Voiceover.from_dict(voiceover_dict))
+
+                content_id_to_voiceovers[content_id][
+                    voiceover_type] = voiceover
+
         return cls(
             entity_voiceovers_dict['entity_id'],
             entity_voiceovers_dict['entity_type'],
@@ -163,7 +178,8 @@ def validate(self) -> None:
                 'language_accent_code must be formatted as '
                 '{{language}}-{{accent}}, received %s' %
                 self.language_accent_code)
-        for content_id, voiceover_type_to_voiceover in self.voiceovers.items():
+        for content_id, voiceover_type_to_voiceover in (
+                self.voiceovers_mapping.items()):
             if not isinstance(content_id, str):
                 raise utils.ValidationError(
                     'content_id must be a string, received %s' % content_id)
@@ -173,13 +189,32 @@ def validate(self) -> None:
                     raise utils.ValidationError(
                         'voiceover type must be VoiceoverType, received %s' %
                         voiceover_type)
-                voiceover.validate()
+                if voiceover is not None:
+                    voiceover.validate()
+
+    def add_new_content_id_without_voiceovers(
+        self,
+        content_id: str
+    ) -> None:
+        """Adds a new content ID for which manual and automatic voiceovers
+        can be added. Initially, both voiceover fields will be empty (None),
+        and they will later be populated with their respective values using the
+        add_voiceover method.
+
+        Args:
+            content_id: str. The new content ID for which voiceovers should be
+                added.
+        """
+        self.voiceovers_mapping[content_id] = {
+            feconf.VoiceoverType.MANUAL: None,
+            feconf.VoiceoverType.AUTO: None
+        }
 
     def add_voiceover(
         self,
         content_id: str,
         voiceover_type: feconf.VoiceoverType,
-        voiceover: state_domain.Voiceover
+        voiceovers_mapping: state_domain.Voiceover
     ) -> None:
         """Adds voiceover to the entity voiceover instance.
 
@@ -188,10 +223,10 @@ def add_voiceover(
                 being added.
             voiceover_type: VoiceoverType. The voiceover type of the given
                 voiceover.
-            voiceover: Voiceover. The voiceover instance to be added to the
-                entity voiceovers object.
+            voiceovers_mapping: Voiceover. The voiceover instance to be added to
+                the entity voiceovers object.
         """
-        self.voiceovers[content_id][voiceover_type] = voiceover
+        self.voiceovers_mapping[content_id][voiceover_type] = voiceovers_mapping
 
     def remove_voiceover(
         self,
@@ -206,7 +241,7 @@ def remove_voiceover(
             voiceover_type: VoiceoverType. The voiceover type of the given
                 voiceover.
         """
-        del self.voiceovers[content_id][voiceover_type]
+        del self.voiceovers_mapping[content_id][voiceover_type]
 
     @classmethod
     def create_empty(
@@ -222,4 +257,4 @@ def create_empty(
             entity_type=entity_type,
             entity_version=entity_version,
             language_accent_code=language_accent_code,
-            voiceovers={})
+            voiceovers_mapping={})

core/domain/voiceover_domain_test.py

@@ -49,7 +49,7 @@ def setUp(self) -> None:
             entity_type=feconf.ENTITY_TYPE_EXPLORATION,
             entity_version=1,
             language_accent_code='en-US',
-            voiceovers={
+            voiceovers_mapping={
                 'content_id_0': {
                     feconf.VoiceoverType.MANUAL: (
                         state_domain.Voiceover.from_dict(
@@ -68,7 +68,7 @@ def test_to_dict_method_of_entity_voiceovers_class(self) -> None:
             'entity_type': 'exploration',
             'entity_version': 1,
             'language_accent_code': 'en-US',
-            'voiceovers': {
+            'voiceovers_mapping': {
                 'content_id_0': {
                     'manual': self.dummy_manual_voiceover_dict,
                     'auto': self.dummy_autogenerated_voiceover_dict
@@ -85,7 +85,7 @@ def test_from_dict_method_of_entity_voiceovers_class(self) -> None:
             'entity_type': 'exploration',
             'entity_version': 1,
             'language_accent_code': 'en-US',
-            'voiceovers': {
+            'voiceovers_mapping': {
                 'content_id_0': {
                     'manual': self.dummy_manual_voiceover_dict,
                     'auto': self.dummy_autogenerated_voiceover_dict
@@ -140,9 +140,10 @@ def test_validate_datatype_of_voiceover_type(self) -> None:
             utils.ValidationError,
             'voiceover type must be VoiceoverType'
         ):
-            self.entity_voiceovers_instance.voiceovers['content_id_0'][1] = ( # type: ignore[index]
-                self.entity_voiceovers_instance.voiceovers['content_id_0'][
-                    feconf.VoiceoverType.MANUAL])
+            self.entity_voiceovers_instance.voiceovers_mapping[
+                'content_id_0'][1] = ( # type: ignore[index]
+                    self.entity_voiceovers_instance.voiceovers_mapping[
+                        'content_id_0'][feconf.VoiceoverType.MANUAL])
             self.entity_voiceovers_instance.validate()
 
     def test_validate_language_accent_code(self) -> None:
@@ -181,7 +182,7 @@ def test_validate_content_id(self) -> None:
             utils.ValidationError,
             'content_id must be a string'
         ):
-            self.entity_voiceovers_instance.voiceovers[1] = None # type: ignore[index, assignment]
+            self.entity_voiceovers_instance.voiceovers_mapping[1] = None # type: ignore[index, assignment]
             self.entity_voiceovers_instance.validate()
 
     def test_add_voiceovers_correctly(self) -> None:
@@ -193,27 +194,32 @@ def test_add_voiceovers_correctly(self) -> None:
         }
         new_voiceover_object = state_domain.Voiceover.from_dict(
             dummy_new_voiceover_dict)
+        manual_voiceover = self.entity_voiceovers_instance.voiceovers_mapping[
+            'content_id_0'][feconf.VoiceoverType.MANUAL]
+        assert isinstance(manual_voiceover, state_domain.Voiceover)
         self.assertDictEqual(
-            self.entity_voiceovers_instance.voiceovers['content_id_0'][
-                feconf.VoiceoverType.MANUAL].to_dict(),
+            manual_voiceover.to_dict(),
             self.dummy_manual_voiceover_dict
         )
 
         self.entity_voiceovers_instance.add_voiceover(
             content_id='content_id_0',
             voiceover_type=feconf.VoiceoverType.MANUAL,
-            voiceover=new_voiceover_object)
+            voiceovers_mapping=new_voiceover_object)
 
+        manual_voiceover = self.entity_voiceovers_instance.voiceovers_mapping[
+            'content_id_0'][feconf.VoiceoverType.MANUAL]
+        assert isinstance(manual_voiceover, state_domain.Voiceover)
         self.assertDictEqual(
-            self.entity_voiceovers_instance.voiceovers['content_id_0'][
-                feconf.VoiceoverType.MANUAL].to_dict(),
+            manual_voiceover.to_dict(),
             dummy_new_voiceover_dict
         )
 
     def test_removes_voiceover_correctly(self) -> None:
         self.assertIn(
             feconf.VoiceoverType.MANUAL,
-            self.entity_voiceovers_instance.voiceovers['content_id_0'].keys())
+            self.entity_voiceovers_instance.voiceovers_mapping[
+                'content_id_0'].keys())
 
         self.entity_voiceovers_instance.remove_voiceover(
             content_id='content_id_0',
@@ -222,17 +228,46 @@ def test_removes_voiceover_correctly(self) -> None:
 
         self.assertNotIn(
             feconf.VoiceoverType.MANUAL,
-            self.entity_voiceovers_instance.voiceovers['content_id_0'].keys())
+            self.entity_voiceovers_instance.voiceovers_mapping[
+                'content_id_0'].keys())
 
-    def test_create_empty_entity_voiceovers_object(self) -> None:
-        empty_entity_voiceovers_object = (
+    def test_create_empty_entity_voiceovers(self) -> None:
+        empty_entity_voiceovers = (
             voiceover_domain.EntityVoiceovers.create_empty(
                 'exp_id', 'exploration', 1, 'en-US'))
 
-        self.assertEqual(empty_entity_voiceovers_object.entity_id, 'exp_id')
-        self.assertEqual(empty_entity_voiceovers_object.entity_version, 1)
+        self.assertEqual(empty_entity_voiceovers.entity_id, 'exp_id')
+        self.assertEqual(empty_entity_voiceovers.entity_version, 1)
         self.assertEqual(
-            empty_entity_voiceovers_object.entity_type, 'exploration')
+            empty_entity_voiceovers.entity_type, 'exploration')
         self.assertEqual(
-            empty_entity_voiceovers_object.language_accent_code, 'en-US')
-        self.assertEqual(empty_entity_voiceovers_object.voiceovers, {})
+            empty_entity_voiceovers.language_accent_code, 'en-US')
+        self.assertEqual(empty_entity_voiceovers.voiceovers_mapping, {})
+
+    def test_should_be_able_to_add_new_content_id(self) -> None:
+        entity_voiceovers_object = (
+            voiceover_domain.EntityVoiceovers.create_empty(
+                'exp_id', 'exploration', 1, 'en-US'))
+
+        self.assertEqual(entity_voiceovers_object.entity_id, 'exp_id')
+        self.assertEqual(entity_voiceovers_object.entity_version, 1)
+        self.assertEqual(
+            entity_voiceovers_object.entity_type, 'exploration')
+        self.assertEqual(
+            entity_voiceovers_object.language_accent_code, 'en-US')
+        self.assertEqual(entity_voiceovers_object.voiceovers_mapping, {})
+
+        entity_voiceovers_object.add_new_content_id_without_voiceovers(
+            'content_1')
+        entity_voiceovers_object.add_voiceover(
+            'content_1',
+            feconf.VoiceoverType.MANUAL,
+            state_domain.Voiceover.from_dict(self.dummy_manual_voiceover_dict))
+
+        manual_voiceover = entity_voiceovers_object.voiceovers_mapping[
+            'content_1'][feconf.VoiceoverType.MANUAL]
+        assert isinstance(manual_voiceover, state_domain.Voiceover)
+
+        self.assertDictEqual(
+            manual_voiceover.to_dict(),
+            self.dummy_manual_voiceover_dict)