Merge pull request #7 from odd12258053/support_http_api_in_aws

Support API Gateway HTTP API ver1.0 and ver2.0 in AWS

Author: odd12258053

.github/workflows/deploy.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Install Flit
         run: pip install flit
       - name: Install Dependencies
-        run: flit install --symlink
+        run: flit install --symlink --deps production
       - name: Publish
         env:
           FLIT_USERNAME: ${{ secrets.FLIT_USERNAME }}

Makefile

@@ -1,16 +1,11 @@
 TARGETS := agraffe
 
-ISORT_OPT := -m3 --tc --py 37
-BLACK_OPT := -t py37 --skip-string-normalization
-FLAKE8_OPT := --max-line-length 88
-MYPY_OPT := --config-file mypy.ini
-
 format:
-	isort ${ISORT_OPT} ${TARGETS}
-	black ${BLACK_OPT} ${TARGETS}
+	isort ${TARGETS}
+	black ${TARGETS}
 
 lint:
-	isort --check-only ${ISORT_OPT} ${TARGETS}
-	black --check ${BLACK_OPT} ${TARGETS}
-	flake8 ${FLAKE8_OPT} ${TARGETS}
-	mypy ${MYPY_OPT} ${TARGETS}
+	isort --check-only ${TARGETS}
+	black --check ${TARGETS}
+	flake8 --config format.ini ${TARGETS}
+	mypy --config-file format.ini ${TARGETS}

README.md

@@ -5,7 +5,7 @@ Agraffe, build API with ASGI in Serverless services (e.g AWS lambda, Google Clou
 
 ## Support Services
 - [x] Google Cloud Functions
-- [x] AWS lambda (with API Gateway REST API)
+- [x] AWS lambda (with API Gateway HTTP API or REST API)
 - [ ] Azure Functions
 
 ## Requirements

agraffe/__init__.py

@@ -1,6 +1,6 @@
-""" Agraffe, build API with ASGI in Serverless services (e.g AWS lambda, Google Cloud Functions). """
+""" Agraffe, build API with ASGI in Serverless services (e.g AWS lambda, Google Cloud Functions). """  # noqa: E501
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 import asyncio
 from enum import Enum
@@ -15,27 +15,14 @@ class Service(str, Enum):
 
 
 class Agraffe:
-    _HttpCycle: Type[ASGICycle]
-
-    def __init__(self, app: ASGIApp, service: Union[str, Service]):
-        if service == Service.google_cloud_functions:
-            from .services import google_cloud_functions
-
-            self._HttpCycle = google_cloud_functions.HttpCycle
-        elif service == Service.aws_lambda:
-            from .services import aws_lambda
-
-            self._HttpCycle = aws_lambda.HttpCycle
-        else:
-            service = ', '.join(map(lambda x: x.value, Service))
-            raise ValueError(f'Please set service either {service}.')
-
+    def __init__(self, app: ASGIApp, http_cycle: Type[ASGICycle]):
         self.app = app
+        self._http_cycle = http_cycle
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
 
-    def __call__(self, request: Any) -> Response:
-        cycle = self._HttpCycle(request)
+    def __call__(self, request: Any) -> Any:
+        cycle = self._http_cycle(request)
         cycle(app=self.app)
         return cycle.response
 
@@ -44,24 +31,20 @@ def entry_point(
         cls, app: ASGIApp, service: Union[str, Service]
     ) -> Callable[..., Any]:
         if service == Service.google_cloud_functions:
+            from .services.google_cloud_functions import HttpCycle as GCPHttpCycle
 
             def _entry_point4gcf(request: Any) -> Response:
-                return cls(app, service)(request=request)
+                return cls(app, GCPHttpCycle)(request=request)
 
             return _entry_point4gcf
 
         elif service == Service.aws_lambda:
+            from .services.aws_lambda import HttpCycle as AWSHttpCycle
 
             def _entry_point4aws_lambda(event: Any, context: Any) -> Any:
-                body, status_code, headers = cls(app, service)(
+                return cls(app, AWSHttpCycle)(
                     request={'event': event, 'context': context}
                 )
-                return {
-                    'statusCode': status_code,
-                    'headers': dict(headers),
-                    'body': body,
-                    'isBase64Encoded': True,
-                }
 
             return _entry_point4aws_lambda
         else:

agraffe/services/aws_lambda.py

@@ -1,3 +1,4 @@
+from base64 import b64decode, b64encode
 from typing import Any, Dict, Iterator
 from urllib.parse import urlencode
 
@@ -6,41 +7,100 @@
 
 Request = Dict[str, Dict[str, Any]]
 
+Response = Dict[str, Any]
 
-class HttpCycle(HttpCycleBase[Request]):
+
+class HttpCycle(HttpCycleBase[Request, Response]):
     @property
     def scope(self) -> Scope:
         event = self.request['event']
 
         def gene_query_string() -> Iterator[str]:
-            params = event['multiValueQueryStringParameters'] or {}
-            for key, values in params.items():
-                for vale in values:
-                    yield urlencode({key: vale})
+            if 'multiValueQueryStringParameters' in event:
+                params = event['multiValueQueryStringParameters'] or {}
+                for key, values in params.items():
+                    for vale in values:
+                        yield urlencode({key: vale})
+            elif 'queryStringParameters' in event:
+                params = event['queryStringParameters'] or {}
+                for key, values in params.items():
+                    for vale in values.split(','):
+                        yield urlencode({key: vale})
+            return
 
         query_string = '&'.join(gene_query_string()).encode()
 
+        if 'httpMethod' in event:
+            method = event['httpMethod']
+        else:
+            method = event['requestContext']['http']['method']
+
+        if 'path' in event:
+            path = event['path']
+        else:
+            path = event['requestContext']['http']['path']
+
+        if 'multiValueHeaders' in event:
+            headers = tuple(
+                (k.lower().encode('latin-1'), (','.join(vs)).encode('latin-1'))
+                for k, vs in event['multiValueHeaders'].items()
+            )
+        else:
+            headers = tuple(
+                (k.lower().encode('latin-1'), v.encode('latin-1'))
+                for k, v in event['headers'].items()
+            )
+
+        if 'cookies' in event:
+            cookies = ';'.join(event['cookies'])
+            headers = headers + (
+                ('cookie'.encode('latin-1'), cookies.encode('latin-1')),
+            )
+
         return {
             'type': 'http',
             'asgi': {'version': '3.0'},
             'http_version': '1.1',
-            'method': event['httpMethod'],
+            'method': method,
             'scheme': 'http',
-            'path': event['path'],
+            'path': path,
             'query_string': query_string,
             'root_path': '',
-            'headers': tuple(
-                (k.lower().encode('latin-1'), v.encode('latin-1'))
-                for k, v in event['headers'].items()
-            ),
+            'headers': headers,
             'server': None,
             'client': None,
         }
 
     async def receive(self) -> Message:
         event = self.request['event']
+        body = event.get('body', '')
+
+        if event.get('isBase64Encoded', False):
+            body = b64decode(body)
+        else:
+            body = body.encode()
         return {
             'type': 'http.request',
-            'body': event.get('body', '').encode(),
+            'body': body,
             'more_body': False,
         }
+
+    @property
+    def response(self) -> Response:
+        event = self.request['event']
+        if 'version' in event:
+            is_base64_encoded = True
+            body = b64encode(self.body).decode()
+        else:
+            is_base64_encoded = False
+            try:
+                body = self.body.decode()
+            except UnicodeDecodeError:
+                is_base64_encoded = True
+                body = b64encode(self.body).decode()
+        return {
+            'statusCode': self.status_code,
+            'headers': dict(self.headers),
+            'body': body,
+            'isBase64Encoded': is_base64_encoded,
+        }

agraffe/services/base.py

@@ -1,13 +1,14 @@
 import asyncio
 from typing import Generic, Iterable, Tuple, TypeVar
 
-from agraffe.types import ASGIApp, Message, Response, Scope
+from agraffe.types import ASGIApp, Message, Scope
 
-T = TypeVar('T')
+Req = TypeVar('Req')
+Res = TypeVar('Res')
 
 
-class HttpCycleBase(Generic[T]):
-    def __init__(self, request: T):
+class HttpCycleBase(Generic[Req, Res]):
+    def __init__(self, request: Req):
         self.request = request
         self.status_code = 200
         self.headers: Iterable[Tuple[str, str]] = ()
@@ -20,8 +21,8 @@ def __call__(self, app: ASGIApp) -> None:
         loop.run_until_complete(task)
 
     @property
-    def response(self) -> Response:
-        return self.body, self.status_code, self.headers
+    def response(self) -> Res:
+        raise NotImplementedError
 
     async def send(self, message: Message) -> None:
         if message['type'] == 'http.response.start':

agraffe/services/google_cloud_functions.py

@@ -18,7 +18,10 @@ def get_data(self, cache: bool, as_text: bool, parse_form_data: bool) -> bytes:
         ...
 
 
-class HttpCycle(HttpCycleBase[Request]):
+Response = Tuple[bytes, int, Iterable[Tuple[str, str]]]
+
+
+class HttpCycle(HttpCycleBase[Request, Response]):
     @property
     def scope(self) -> Scope:
         return {
@@ -51,3 +54,7 @@ async def receive(self) -> Message:
             or b'',
             'more_body': False,
         }
+
+    @property
+    def response(self) -> Response:
+        return self.body, self.status_code, self.headers

agraffe/types.py

@@ -1,12 +1,13 @@
-from typing import Any, Awaitable, Callable, Iterable, MutableMapping, Tuple
+from typing import Any, Awaitable, Callable, MutableMapping
 
 from typing_extensions import Protocol
 
 Message = MutableMapping[str, Any]
 Scope = MutableMapping[str, Any]
 Receive = Callable[[], Awaitable[Message]]
 Send = Callable[[Message], Awaitable[None]]
-Response = Tuple[bytes, int, Iterable[Tuple[str, str]]]
+Request = Any
+Response = Any
 
 
 class ASGIApp(Protocol):
@@ -15,7 +16,7 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
 
 
 class ASGICycle(Protocol):
-    def __init__(self, request: Any) -> None:
+    def __init__(self, request: Request) -> None:
         ...
 
     def __call__(self, app: ASGIApp) -> None:

example/.gitignore

@@ -1,5 +1,4 @@
 node_modules/
 agraffe/
 .serverless/
-serverless_http.yml
 package-lock.json

example/app.py

@@ -0,0 +1,62 @@
+from typing import Optional
+
+from fastapi import Cookie, FastAPI, Header, HTTPException
+from fastapi.responses import PlainTextResponse, Response
+
+from models import Item
+
+
+app = FastAPI()
+
+
+@app.get('/')
+def root():
+    return {'Hello': 'World'}
+
+
+@app.get('/empty')
+def empty():
+    return {}
+
+
+@app.get('/empty/text')
+def empty_text():
+    return ''
+
+
+@app.get('/none')
+def none():
+    return None
+
+
+@app.get('/items/{item_id}')
+def read_item(item_id: int, q: Optional[str] = None):
+    return {'item_id': item_id, 'q': q}
+
+
+@app.post('/items')
+def post_item(item: Item, authorization: Optional[str] = Header(None)):
+    if authorization is None or authorization != 'Bearer foobar':
+        raise HTTPException(status_code=401)
+    return item
+
+
+@app.get('/cookies')
+def cookies(c1: Optional[str] = Cookie(None), c2: Optional[str] = Cookie(None)):
+    return {
+        'c1': c1,
+        'c2': c2,
+    }
+
+
+@app.get('/text')
+def text():
+    return PlainTextResponse('test message!')
+
+
+@app.get('/image')
+def image():
+    return Response(
+        content=b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x0c\x00\x00\x00\x0c\x08\x02\x00\x00\x00\xd9\x17\xcb\xb0\x00\x00\x00\x16IDATx\x9ccLIIa \x04\x98\x08\xaa\x18U4\x00\x8a\x00\x1c\xa2\x01D2\xdd\xa6B\x00\x00\x00\x00IEND\xaeB`\x82',
+        media_type='image/png'
+    )