adds alexa skill event

Author: bweigel

lawip/alexa_skill_event.py

@@ -0,0 +1,142 @@
+from collections import namedtuple
+from typing import Dict
+
+IntentSlot = namedtuple("IntentSlot", ['name', 'value'])
+AlexaSkillUser = namedtuple("AlexaSkillUser", ["userId"])
+AlexaSkillApplication = namedtuple("AlexaSkillApplication", ["applicationId"])
+
+
+def parse_intents(slots: Dict[str, Dict[str, str]]) -> Dict[str, IntentSlot]:
+    return {slot_name: IntentSlot(slot.get("key"),
+                                  slot.get("value")) for slot_name, slot in slots.items()}
+
+
+class AlexaIntent:
+    def __init__(self, name: str,
+                 slots: Dict):
+        self._name = name
+        self._slots = parse_intents(slots)
+
+    @classmethod
+    def from_json(cls, intent: Dict):
+        return cls(**intent)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def slots(self) -> Dict[str, IntentSlot]:
+        return self._slots
+
+
+class AlexaSkillRequest:
+    def __init__(self, locale: str, timestamp: str,
+                 type: str, requestId: str,
+                 intent: Dict = None, reason: str = None):
+        self._locale = locale
+        self._timestamp = timestamp
+        self._request_id = requestId
+        self._type = type
+        self._intent = AlexaIntent(**intent)
+        self._reason = reason
+
+    @classmethod
+    def from_json(cls, session: Dict):
+        return cls(**session)
+
+    @property
+    def locale(self) -> str:
+        return self._locale
+
+    @property
+    def timestamp(self) -> str:
+        return self._timestamp
+
+    @property
+    def request_id(self) -> str:
+        return self._request_id
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def reason(self) -> str:
+        return self._reason
+
+    @property
+    def intent(self) -> AlexaIntent:
+        return self._intent
+
+
+class AlexaSkillSession:
+    def __init__(self, new: bool,
+                 sessionId: str,
+                 user: Dict[str, str],
+                 application: Dict[str, str],
+                 attributes: Dict = None):
+        self._new = new
+        self._session_id = sessionId
+        self._attributes = attributes
+        self._user = AlexaSkillUser(**user)
+        self._application = AlexaSkillApplication(**application)
+
+    @classmethod
+    def from_json(cls, session):
+        return cls(**session)
+
+    @property
+    def new(self) -> bool:
+        return self._new
+
+    @property
+    def session_id(self) -> str:
+        return self._session_id
+
+    @property
+    def attributes(self) -> Dict:
+        return self._attributes
+
+    @property
+    def user(self) -> AlexaSkillUser:
+        return self._user
+
+    @property
+    def application(self) -> AlexaSkillApplication:
+        return self._application
+
+
+class AlexaSkillContext:
+    def __init__(self, AudioPlayer, System, **kwargs):
+        pass
+
+
+class AlexaSkillEvent:
+    def __init__(self, session: Dict,
+                 version: str, request: Dict,
+                 context: Dict):
+        self._session = AlexaSkillSession(**session)
+        self._version = version
+        self._request = AlexaSkillRequest(**request)
+        self._context = AlexaSkillContext(**context)
+
+    @classmethod
+    def from_event(cls, event):
+        return cls(**event)
+
+    @property
+    def session(self) -> AlexaSkillSession:
+        return self._session
+
+    @property
+    def event_version(self) -> str:
+        return self._version
+
+    @property
+    def request(self) -> AlexaSkillRequest:
+        return self._request
+
+    @property
+    def context(self) -> AlexaSkillContext:
+        return self._context

lawip/test/resources/alexa-event.json

@@ -0,0 +1,47 @@
+{
+  "session": {
+    "new": false,
+    "sessionId": "amzn1.echo-api.session.[unique-value-here]",
+    "attributes": {},
+    "user": {
+      "userId": "amzn1.ask.account.[unique-value-here]"
+    },
+    "application": {
+      "applicationId": "amzn1.ask.skill.[unique-value-here]"
+    }
+  },
+  "version": "1.0",
+  "request": {
+    "locale": "en-US",
+    "timestamp": "2016-10-27T21:06:28Z",
+    "type": "IntentRequest",
+    "requestId": "amzn1.echo-api.request.[unique-value-here]",
+    "intent": {
+      "slots": {
+        "Item": {
+          "name": "Item",
+          "value": "snowball"
+        }
+      },
+      "name": "RecipeIntent"
+    }
+  },
+  "context": {
+    "AudioPlayer": {
+      "playerActivity": "IDLE"
+    },
+    "System": {
+      "device": {
+        "supportedInterfaces": {
+          "AudioPlayer": {}
+        }
+      },
+      "application": {
+        "applicationId": "amzn1.ask.skill.[unique-value-here]"
+      },
+      "user": {
+        "userId": "amzn1.ask.account.[unique-value-here]"
+      }
+    }
+  }
+}

lawip/test/test_alexaskill_event.py

@@ -0,0 +1,31 @@
+from unittest2 import TestCase
+
+from lawip.alexa_skill_event import AlexaSkillEvent
+from lawip.sns_event import SnsEvent
+
+from lawip.test.util import get_event_dict
+
+
+class TestSnsEvent(TestCase):
+    def setUp(self):
+        event_dict = get_event_dict("alexa-event.json")
+        self.event = AlexaSkillEvent.from_event(event_dict)
+
+    def test_alexa_skill(self):
+        evt = self.event
+        self.assertEqual(evt.event_version, "1.0")
+        self.assertIsNotNone(evt.request)
+        self.assertIsNotNone(evt.session)
+        self.assertIsNotNone(evt.context)
+
+    def test_skill_session(self):
+        session = self.event.session
+        self.assertEqual(session.application.applicationId, "amzn1.ask.skill.[unique-value-here]")
+        self.assertEqual(session.session_id, "amzn1.echo-api.session.[unique-value-here]")
+        self.assertFalse(session.new)
+
+    def test_skill_request(self):
+        request = self.event.request
+        self.assertEqual(request.intent.name, "RecipeIntent")
+        self.assertEqual(request.intent.slots.get("Item").value, "snowball")
+        self.assertEqual(request.locale, "en-US")