Update key names in adapt keyword registration message

mycroft/skills/intent_service.py

@@ -358,12 +358,18 @@ def handle_register_vocab(self, message):
         Args:
             message (Message): message containing vocab info
         """
-        start_concept = message.data.get('start')
-        end_concept = message.data.get('end')
+        # TODO: 22.02 Remove backwards compatibility
+        if _is_old_style_keyword_message(message):
+            LOG.warning('Deprecated: Registering keywords with old message. '
+                        'This will be removed in v22.02.')
+            _update_keyword_message(message)
+
+        entity_value = message.data.get('entity_value')
+        entity_type = message.data.get('entity_type')
         regex_str = message.data.get('regex')
         alias_of = message.data.get('alias_of')
-        self.adapt_service.register_vocab(start_concept, end_concept,
-                                          alias_of, regex_str)
+        self.adapt_service.register_vocabulary(entity_value, entity_type,
+                                               alias_of, regex_str)
         self.registered_vocab.append(message.data)
 
     def handle_register_intent(self, message):
@@ -554,3 +560,29 @@ def handle_entity_manifest(self, message):
         self.bus.emit(message.reply(
             "intent.service.padatious.entities.manifest",
             {"entities": self.padatious_service.registered_entities}))
+
+
+def _is_old_style_keyword_message(message):
+    """Simple check that the message is not using the updated format.
+
+    TODO: Remove in v22.02
+
+    Args:
+        message (Message): Message object to check
+
+    Returns:
+        (bool) True if this is an old messagem, else False
+    """
+    return ('entity_value' not in message.data and 'start' in message.data)
+
+
+def _update_keyword_message(message):
+    """Make old style keyword registration message compatible.
+
+    Copies old keys in message data to new names.
+
+    Args:
+        message (Message): Message to update
+    """
+    message.data['entity_value'] = message.data['start']
+    message.data['entity_type'] = message.data['end']

mycroft/skills/intent_service_interface.py

@@ -44,15 +44,27 @@ def register_adapt_keyword(self, vocab_type, entity, aliases=None):
 
             vocab_type(str): Keyword reference
             entity (str): Primary keyword
-            aliases (list): List of alternative kewords
+            aliases (list): List of alternative keywords
         """
+        # TODO 22.02: Remove compatibility data
         aliases = aliases or []
-        self.bus.emit(Message("register_vocab",
-                              {'start': entity, 'end': vocab_type}))
+        entity_data = {'entity_value': entity, 'entity_type': vocab_type}
+        compatibility_data = {'start': entity, 'end': vocab_type}
+
+        self.bus.emit(
+            Message("register_vocab",
+                    {**entity_data, **compatibility_data})
+        )
         for alias in aliases:
-            self.bus.emit(Message("register_vocab", {
-                'start': alias, 'end': vocab_type, 'alias_of': entity
-            }))
+            alias_data = {
+                'entity_value': alias,
+                'entity_type': vocab_type,
+                'alias_of': entity}
+            compatibility_data = {'start': alias, 'end': vocab_type}
+            self.bus.emit(
+                Message("register_vocab",
+                        {**alias_data, **compatibility_data})
+            )
 
     def register_adapt_regex(self, regex):
         """Register a regex with the intent service.

mycroft/skills/intent_services/adapt_service.py

@@ -249,14 +249,35 @@ def take_best(intent, utt):
             ret = None
         return ret
 
+    # TODO 22.02: Remove this deprecated method
     def register_vocab(self, start_concept, end_concept, alias_of, regex_str):
-        """Register vocabulary."""
+        """Register Vocabulary. DEPRECATED
+
+        This method should not be used, it has been replaced by
+        register_vocabulary().
+        """
+        self.register_vocabulary(start_concept, end_concept,
+                                 alias_of, regex_str)
+
+    def register_vocabulary(self, entity_value, entity_type,
+                            alias_of, regex_str):
+        """Register skill vocabulary as adapt entity.
+
+        This will handle both regex registration and registration of normal
+        keywords. if the "regex_str" argument is set all other arguments will
+        be ignored.
+
+        Argument:
+            entity_value: the natural langauge word
+            entity_type: the type/tag of an entity instance
+            alias_of: entity this is an alternative for
+        """
         with self.lock:
             if regex_str:
                 self.engine.register_regex_entity(regex_str)
             else:
                 self.engine.register_entity(
-                    start_concept, end_concept, alias_of=alias_of)
+                    entity_value, entity_type, alias_of=alias_of)
 
     def register_intent(self, intent):
         """Register new intent with adapt engine.

mycroft/skills/mycroft_skill/mycroft_skill.py

@@ -1168,9 +1168,8 @@ def register_vocabulary(self, entity, entity_type):
             entity:         word to register
             entity_type:    Intent handler entity to tie the word to
         """
-        self.bus.emit(Message('register_vocab', {
-            'start': entity, 'end': to_alnum(self.skill_id) + entity_type
-        }))
+        keyword_type = to_alnum(self.skill_id) + entity_type
+        self.intent_service.register_adapt_keyword(keyword_type, entity)
 
     def register_regex(self, regex_str):
         """Register a new regex.

test/unittests/skills/test_intent_service.py

@@ -214,12 +214,18 @@ def test_lang_exists(self):
         self.assertEqual(_get_message_lang(msg), 'sv-se')
 
 
-def create_vocab_msg(keyword, value):
+def create_old_style_vocab_msg(keyword, value):
     """Create a message for registering an adapt keyword."""
     return Message('register_vocab',
                    {'start': value, 'end': keyword})
 
 
+def create_vocab_msg(keyword, value):
+    """Create a message for registering an adapt keyword."""
+    return Message('register_vocab',
+                   {'entity_value': value, 'entity_type': keyword})
+
+
 def get_last_message(bus):
     """Get last sent message on mock bus."""
     last = bus.emit.call_args
@@ -230,14 +236,27 @@ class TestIntentServiceApi(TestCase):
     def setUp(self):
         self.intent_service = IntentService(mock.Mock())
 
-    def setup_simple_adapt_intent(self):
-        msg = create_vocab_msg('testKeyword', 'test')
+    def setup_simple_adapt_intent(self,
+                                  msg=create_vocab_msg('testKeyword', 'test')):
         self.intent_service.handle_register_vocab(msg)
 
         intent = IntentBuilder('skill:testIntent').require('testKeyword')
         msg = Message('register_intent', intent.__dict__)
         self.intent_service.handle_register_intent(msg)
 
+    def test_keyword_backwards_compatibility(self):
+        self.setup_simple_adapt_intent(
+            create_old_style_vocab_msg('testKeyword', 'test')
+        )
+
+        # Check that the intent is returned
+        msg = Message('intent.service.adapt.get', data={'utterance': 'test'})
+        self.intent_service.handle_get_adapt(msg)
+
+        reply = get_last_message(self.intent_service.bus)
+        self.assertEqual(reply.data['intent']['intent_type'],
+                         'skill:testIntent')
+
     def test_get_adapt_intent(self):
         self.setup_simple_adapt_intent()
         # Check that the intent is returned
@@ -300,8 +319,8 @@ def test_get_adapt_vocab_manifest(self):
         msg = Message('intent.service.adapt.vocab.manifest.get')
         self.intent_service.handle_vocab_manifest(msg)
         reply = get_last_message(self.intent_service.bus)
-        value = reply.data['vocab'][0]['start']
-        keyword = reply.data['vocab'][0]['end']
+        value = reply.data['vocab'][0]['entity_value']
+        keyword = reply.data['vocab'][0]['entity_type']
         self.assertEqual(keyword, 'testKeyword')
         self.assertEqual(value, 'test')
 

test/unittests/skills/test_intent_service_interface.py

@@ -25,13 +25,15 @@ def reset(self):
         self.results = []
 
 
-class FunctionTest(unittest.TestCase):
-    def check_emitter(self, result_list):
-        for type in self.emitter.get_types():
-            self.assertEqual(type, 'register_vocab')
-        self.assertEqual(sorted(self.emitter.get_results(),
-                                key=lambda d: sorted(d.items())),
-                         sorted(result_list, key=lambda d: sorted(d.items())))
+class KeywordRegistrationTest(unittest.TestCase):
+    def check_emitter(self, expected_message_data):
+        """Verify that the registration messages matches the expected."""
+        for msg_type in self.emitter.get_types():
+            self.assertEqual(msg_type, 'register_vocab')
+        self.assertEqual(
+            sorted(self.emitter.get_results(),
+                   key=lambda d: sorted(d.items())),
+            sorted(expected_message_data, key=lambda d: sorted(d.items())))
         self.emitter.reset()
 
     def setUp(self):
@@ -40,18 +42,40 @@ def setUp(self):
     def test_register_keyword(self):
         intent_service = IntentServiceInterface(self.emitter)
         intent_service.register_adapt_keyword('test_intent', 'test')
-        self.check_emitter([{'start': 'test', 'end': 'test_intent'}])
+        entity_data = {'entity_value': 'test', 'entity_type': 'test_intent'}
+        compatibility_data = {'start': 'test', 'end': 'test_intent'}
+        expected_data = {**entity_data, **compatibility_data}
+        self.check_emitter([expected_data])
 
     def test_register_keyword_with_aliases(self):
+        # TODO 22.02: Remove compatibility data
         intent_service = IntentServiceInterface(self.emitter)
         intent_service.register_adapt_keyword('test_intent', 'test',
                                               ['test2', 'test3'])
-        self.check_emitter([{'start': 'test', 'end': 'test_intent'},
-                            {'start': 'test2', 'end': 'test_intent',
-                             'alias_of': 'test'},
-                            {'start': 'test3', 'end': 'test_intent',
-                             'alias_of': 'test'},
-                            ])
+
+        entity_data = {'entity_value': 'test', 'entity_type': 'test_intent'}
+        compatibility_data = {'start': 'test', 'end': 'test_intent'}
+        expected_initial_vocab = {**entity_data, **compatibility_data}
+
+        alias_data = {
+            'entity_value': 'test2',
+            'entity_type': 'test_intent',
+            'alias_of': 'test'
+        }
+        alias_compatibility = {'start': 'test2', 'end': 'test_intent'}
+        expected_alias1 = {**alias_data, **alias_compatibility}
+
+        alias_data2 = {
+            'entity_value': 'test3',
+            'entity_type': 'test_intent',
+            'alias_of': 'test'
+        }
+        alias_compatibility2 = {'start': 'test3', 'end': 'test_intent'}
+        expected_alias2 = {**alias_data2, **alias_compatibility2}
+
+        self.check_emitter([expected_initial_vocab,
+                            expected_alias1,
+                            expected_alias2])
 
     def test_register_regex(self):
         intent_service = IntentServiceInterface(self.emitter)

test/unittests/skills/test_mycroft_skill.py

@@ -303,7 +303,14 @@ def test_register_vocab(self):
 
         # Normal vocaubulary
         self.emitter.reset()
-        expected = [{'start': 'hello', 'end': 'AHelloKeyword'}]
+        expected = [
+            {
+                'start': 'hello',
+                'end': 'AHelloKeyword',
+                'entity_value': 'hello',
+                'entity_type': 'AHelloKeyword'
+            }
+        ]
         s.register_vocabulary('hello', 'HelloKeyword')
         self.check_register_vocabulary(expected)
         # Regex