Merge pull request #1 from hypoport/dev

Updates README & adds CF + Alexa Skill Events

Author: bweigel

README.rst

@@ -2,35 +2,26 @@
 LaWip
 ===========
 
-LaWip provides data-classes for AWS lambda events::
+LaWip provides data-classes for AWS lambda events
 
-    #!/usr/bin/env python
+**Installation**
 
-    from towelstuff import location
-    from towelstuff import utils
+::
 
-    if utils.has_towel():
-        print "Your towel is located:", location.where_is_my_towel()
+    # current version
+    pip install git+https://github.com/bweigel/LaWip.git
 
+    # using a tagged/released version
+    pip install git+https://github.com/bweigel/[email protected]
 
-A Section
-=========
+**Test using tox**
 
-Lists look like this:
+::
 
-* First
+    tox
 
-* Second. Can be multiple lines
-  but must be indented properly.
+**Test using setup.py**
 
-A Sub-Section
--------------
+::
 
-Numbered lists look like you'd expect:
-
-1. hi there
-
-2. must be going
-
-Urls are http://like.this and links can be
-written `like this <http://www.example.com/foo/bar>`_.
+    python setup.py test

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) if isinstance(intent, dict) else None
+        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/cf_event.py

@@ -0,0 +1,146 @@
+from collections import namedtuple
+from typing import Dict
+
+HeaderDict = namedtuple("HeaderDict", ['key', 'value'])
+
+
+def parse_headers(headers):
+    return {hdr_name: HeaderDict(header[0].get("key", None),
+                                 header[0].get("value", None)) for hdr_name, header in headers.items()}
+
+
+class CfConfig:
+    def __init__(self, distribution_id: str, request_id: str):
+        self._distribution_id = distribution_id
+        self._request_id = request_id
+
+    @classmethod
+    def from_json(cls, config):
+        return cls(config["distributionId"],
+                   config["requestId"])
+
+    @property
+    def distribution_id(self) -> str:
+        return self._distribution_id
+
+    @property
+    def request_id(self) -> str:
+        return self._request_id
+
+
+class CfRequest:
+    def __init__(self, client_ip: str,
+                 querystring: str,
+                 uri: str,
+                 method: str,
+                 headers: Dict[str, HeaderDict],
+                 origin):
+        self._client_ip = client_ip
+        self._querystring = querystring
+        self._uri = uri
+        self._http_method = method
+        self._headers = headers
+        self._origin = origin
+
+    @classmethod
+    def from_json(cls, request):
+        return cls(request["clientIp"],
+                   request["querystring"],
+                   request["uri"],
+                   request["method"],
+                   parse_headers(request["headers"]),
+                   request.get("origin", None))
+
+    @property
+    def client_ip(self) -> str:
+        return self._client_ip
+
+    @property
+    def querystring(self) -> str:
+        return self._querystring
+
+    @property
+    def uri(self) -> str:
+        return self._uri
+
+    @property
+    def http_method(self) -> str:
+        return self._http_method
+
+    @property
+    def headers(self) -> Dict[str, HeaderDict]:
+        return self._headers
+
+    @property
+    def origin(self):
+        return self._origin
+
+
+class CfResponse:
+    def __init__(self, status: str, status_description: str, headers: Dict[str, HeaderDict]):
+        self._status = status
+        self._status_description = status_description
+        self._headers = headers
+
+    @classmethod
+    def from_json(cls, response):
+        if response is not None:
+            return cls(response["status"],
+                       response["statusDescription"],
+                       parse_headers(response["headers"]))
+
+    @property
+    def status(self) -> str:
+        return self._status
+
+    @property
+    def status_description(self) -> str:
+        return self._status_description
+
+    @property
+    def headers(self) -> Dict[str, HeaderDict]:
+        return self._headers
+
+
+class CfRecord:
+    def __init__(self, config: CfConfig,
+                 request: CfRequest,
+                 response: CfResponse):
+        self._config = config
+        self._request = request
+        self._response = response
+
+    @classmethod
+    def from_json(cls, cf):
+        return cls(CfConfig.from_json(cf["config"]),
+                   CfRequest.from_json(cf["request"]),
+                   CfResponse.from_json(cf.get("response", None)))
+
+    @property
+    def config(self) -> CfConfig:
+        return self._config
+
+    @property
+    def request(self) -> CfRequest:
+        return self._request
+
+    @property
+    def response(self) -> CfResponse:
+        return self._response
+
+
+class CloudfrontEvent:
+    def __init__(self, records: [CfRecord]):
+        self._records = records
+
+    @classmethod
+    def from_event(cls, event):
+        return cls([CfRecord.from_json(record["cf"]) for record in event["Records"]])
+
+    @property
+    def records(self) -> [CfRecord]:
+        return self._records
+
+    @property
+    def first_record(self) -> CfRecord:
+        return self._records[0]

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]"
+      }
+    }
+  }
+}