class SearchResponse(BaseModel):
cards: List[Card]
async def wake_up():
logger.info("waking up model")
search("wake up")
@app.get("/search")
async def search_endpoint(q: str, top: int = 10) -> SearchResponse:
top = search(q, top)
cards = [Card(name=c.name, text=c.text) for c in top]
return SearchResponse(cards=cards)
@app.get("/", response_class=HTMLResponse)
async def home():
asyncio.create_task(wake_up())
if HOME_HTML.exists():
with HOME_HTML.open() as f:
body = f.read()
else:
body = "not found :("
return body
handler = Mangum(app)
"""AWS Lambda handler.""" from mangum import Mangum from dashboard_api.main import app handler = Mangum(app, enable_lifespan=False)
def test_http_request(mock_http_event, query_string) -> None:
async def app(scope, receive, send):
assert scope == {
"asgi": {
"version": "3.0"
},
"aws.context": {},
"aws.event": {
"body":
None,
"headers": {
"Accept":
"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Encoding": "gzip, deflate, lzma, sdch, "
"br",
"Accept-Language": "en-US,en;q=0.8",
"CloudFront-Forwarded-Proto": "https",
"CloudFront-Is-Desktop-Viewer": "true",
"CloudFront-Is-Mobile-Viewer": "false",
"CloudFront-Is-SmartTV-Viewer": "false",
"CloudFront-Is-Tablet-Viewer": "false",
"CloudFront-Viewer-Country": "US",
"Host": "test.execute-api.us-west-2.amazonaws.com",
"Upgrade-Insecure-Requests": "1",
"X-Forwarded-For": "192.168.100.1, 192.168.1.1",
"X-Forwarded-Port": "443",
"X-Forwarded-Proto": "https",
},
"httpMethod":
"GET",
"path":
"/test/hello",
"pathParameters": {
"proxy": "hello"
},
"queryStringParameters":
mock_http_event["queryStringParameters"],
"multiValueQueryStringParameters":
mock_http_event["multiValueQueryStringParameters"],
"requestContext": {
"accountId": "123456789012",
"apiId": "123",
"httpMethod": "GET",
"identity": {
"accountId":
"",
"apiKey":
"",
"caller":
"",
"cognitoAuthenticationProvider":
"",
"cognitoAuthenticationType":
"",
"cognitoIdentityId":
"",
"cognitoIdentityPoolId":
"",
"sourceIp":
"192.168.100.1",
"user":
"",
"userAgent":
"Mozilla/5.0 "
"(Macintosh; "
"Intel Mac OS "
"X 10_11_6) "
"AppleWebKit/537.36 "
"(KHTML, like "
"Gecko) "
"Chrome/52.0.2743.82 "
"Safari/537.36 "
"OPR/39.0.2256.48",
"userArn":
"",
},
"requestId": "41b45ea3-70b5-11e6-b7bd-69b5aaebc7d9",
"resourceId": "us4z18",
"resourcePath": "/{proxy+}",
"stage": "Prod",
},
"resource":
"/{proxy+}",
"stageVariables": {
"stageVarName": "stageVarValue"
},
},
"client": ("192.168.100.1", 0),
"headers": [
[
b"accept",
b"text/html,application/xhtml+xml,application/xml;q=0.9,image/"
b"webp,*/*;q=0.8",
],
[b"accept-encoding", b"gzip, deflate, lzma, sdch, br"],
[b"accept-language", b"en-US,en;q=0.8"],
[b"cloudfront-forwarded-proto", b"https"],
[b"cloudfront-is-desktop-viewer", b"true"],
[b"cloudfront-is-mobile-viewer", b"false"],
[b"cloudfront-is-smarttv-viewer", b"false"],
[b"cloudfront-is-tablet-viewer", b"false"],
[b"cloudfront-viewer-country", b"US"],
[b"host", b"test.execute-api.us-west-2.amazonaws.com"],
[b"upgrade-insecure-requests", b"1"],
[b"x-forwarded-for", b"192.168.100.1, 192.168.1.1"],
[b"x-forwarded-port", b"443"],
[b"x-forwarded-proto", b"https"],
],
"http_version":
"1.1",
"method":
"GET",
"path":
"/test/hello",
"query_string":
query_string,
"raw_path":
None,
"root_path":
"",
"scheme":
"https",
"server": ("test.execute-api.us-west-2.amazonaws.com", 80),
"type":
"http",
}
await send({
"type":
"http.response.start",
"status":
200,
"headers": [[b"content-type", b"text/plain; charset=utf-8"]],
})
await send({"type": "http.response.body", "body": b"Hello, world!"})
handler = Mangum(app, enable_lifespan=False)
response = handler(mock_http_event, {})
assert response == {
"statusCode": 200,
"isBase64Encoded": False,
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"body": "Hello, world!",
}
def test_invalid_dsn(mock_ws_connect_event, mock_websocket_app, dsn):
handler = Mangum(mock_websocket_app, dsn=dsn)
with pytest.raises(ConfigurationError):
handler(mock_ws_connect_event, {})
prefix="/api/v1/impressions/hourly")
app.include_router(impressions_daily.router,
prefix="/api/v1/impressions/daily")
app.include_router(impressions_monthly.router,
prefix="/api/v1/impressions/monthly")
# Add middleware.
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.add_middleware(SentryAsgiMiddleware)
api_handler = Mangum(app) if os.environ.get("AWS_EXECUTION_ENV") else None
# Add routes that are not managed by routers.
@app.get("/")
def root() -> Dict[str, str]:
"""Get demo."""
return {"message": "Hello World"}
# TODO: Prefer HTTPException without handle, currently nothing must be handled
# # Add exception handlers.
# @app.exception_handler(StarletteHTTPException)
# def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse:
# """Handle generic HTTP exceptions."""
# return JSONResponse(content=jsonable_encoder({"detail": str(exc)}))
"name": score.name,
"subject": score.subject,
"score": score.score,
} for score in ExamResultsTable.query(student)]
if subject:
body = [{
"name": score.name,
"subject": score.subject,
"score": score.score,
} for score in SubjectIndex.query(subject)]
return {"exam_results": body}
handler = Mangum(
app, False) # FastAPIのインスタンスをMangumのコンストラクタに渡して、handlerとして読めるようにしておく
# ---------------------------
# ローカル環境の初期化用
# ---------------------------
def init_ddb_local():
if ExamResultsTable.Meta.host and not ExamResultsTable.exists():
print('creating a table...')
ExamResultsTable.create_table(read_capacity_units=1,
write_capacity_units=1,
wait=True)
print('Done.')
def test_websocket_group_events(mock_ws_connect_event, mock_ws_send_event,
mock_ws_disconnect_event, dynamodb) -> None:
table_name = "test-table"
dynamodb.create_table(
TableName=table_name,
KeySchema=[{
"AttributeName": "connectionId",
"KeyType": "HASH"
}],
AttributeDefinitions=[{
"AttributeName": "connectionId",
"AttributeType": "S"
}],
ProvisionedThroughput={
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
},
)
async def app(scope, receive, send):
assert scope == {
"aws": {
"context": {},
"event": {
"headers": {
"Accept-Encoding":
"gzip, deflate, br",
"Accept-Language":
"en-US,en;q=0.9",
"Cache-Control":
"no-cache",
"Host":
"test.execute-api.ap-southeast-1.amazonaws.com",
"Origin":
"https://test.execute-api.ap-southeast-1.amazonaws.com",
"Pragma":
"no-cache",
"Sec-WebSocket-Extensions":
"permessage-deflate; "
"client_max_window_bits",
"Sec-WebSocket-Key":
"bnfeqmh9SSPr5Sg9DvFIBw==",
"Sec-WebSocket-Version":
"13",
"User-Agent":
"Mozilla/5.0 (Macintosh; Intel "
"Mac OS X 10_14_5) "
"AppleWebKit/537.36 (KHTML, like "
"Gecko) Chrome/75.0.3770.100 "
"Safari/537.36",
"X-Amzn-Trace-Id":
"Root=1-5d465cb6-78ddcac1e21f89203d004a89",
"X-Forwarded-For":
"192.168.100.1",
"X-Forwarded-Port":
"443",
"X-Forwarded-Proto":
"https",
},
"isBase64Encoded": False,
"multiValueHeaders": {
"Accept-Encoding": ["gzip, deflate, "
"br"],
"Accept-Language": ["en-US,en;q=0.9"],
"Cache-Control": ["no-cache"],
"Host":
["test.execute-api.ap-southeast-1.amazonaws.com"],
"Origin": [
"https://test.execute-api.ap-southeast-1.amazonaws.com"
],
"Pragma": ["no-cache"],
"Sec-WebSocket-Extensions":
["permessage-deflate; "
"client_max_window_bits"],
"Sec-WebSocket-Key": ["bnfeqmh9SSPr5Sg9DvFIBw=="],
"Sec-WebSocket-Version": ["13"],
"User-Agent": [
"Mozilla/5.0 "
"(Macintosh; Intel Mac "
"OS X 10_14_5) "
"AppleWebKit/537.36 "
"(KHTML, like Gecko) "
"Chrome/75.0.3770.100 "
"Safari/537.36"
],
"X-Amzn-Trace-Id":
["Root=1-5d465cb6-78ddcac1e21f89203d004a89"],
"X-Forwarded-For": ["192.168.100.1"],
"X-Forwarded-Port": ["443"],
"X-Forwarded-Proto": ["https"],
},
"requestContext": {
"apiId": "test",
"connectedAt": 1564892342293,
"connectionId": "d4NsecoByQ0CH-Q=",
"domainName":
"test.execute-api.ap-southeast-1.amazonaws.com",
"eventType": "CONNECT",
"extendedRequestId": "d4NseGc4yQ0FsSA=",
"identity": {
"accessKey":
None,
"accountId":
None,
"caller":
None,
"cognitoAuthenticationProvider":
None,
"cognitoAuthenticationType":
None,
"cognitoIdentityId":
None,
"cognitoIdentityPoolId":
None,
"principalOrgId":
None,
"sourceIp":
"192.168.100.1",
"user":
None,
"userAgent":
"Mozilla/5.0 "
"(Macintosh; "
"Intel Mac OS "
"X 10_14_5) "
"AppleWebKit/537.36 "
"(KHTML, like "
"Gecko) "
"Chrome/75.0.3770.100 "
"Safari/537.36",
"userArn":
None,
},
"messageDirection": "IN",
"messageId": None,
"requestId": "d4NseGc4yQ0FsSA=",
"requestTime": "04/Aug/2019:04:19:02 "
"+0000",
"requestTimeEpoch": 1564892342293,
"routeKey": "$connect",
"stage": "Prod",
},
},
},
"client": ["192.168.100.1", 0],
"headers": [
[b"accept-encoding", b"gzip, deflate, br"],
[b"accept-language", b"en-US,en;q=0.9"],
[b"cache-control", b"no-cache"],
[b"host", b"test.execute-api.ap-southeast-1.amazonaws.com"],
[
b"origin",
b"https://test.execute-api.ap-southeast-1.amazonaws.com"
],
[b"pragma", b"no-cache"],
[
b"sec-websocket-extensions",
b"permessage-deflate; client_max_window_bits",
],
[b"sec-websocket-key", b"bnfeqmh9SSPr5Sg9DvFIBw=="],
[b"sec-websocket-version", b"13"],
[
b"user-agent",
b"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/"
b"537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36",
],
[
b"x-amzn-trace-id",
b"Root=1-5d465cb6-78ddcac1e21f89203d004a89"
],
[b"x-forwarded-for", b"192.168.100.1"],
[b"x-forwarded-port", b"443"],
[b"x-forwarded-proto", b"https"],
],
"path":
"/",
"query_string":
b"",
"raw_path":
None,
"root_path":
"Prod",
"scheme":
"https",
"server": ["test.execute-api.ap-southeast-1.amazonaws.com", 443],
"type":
"websocket",
}
await send({"type": "websocket.accept", "subprotocol": None})
await send({
"type": "websocket.send",
"text": "Hello world!",
"group": "testgroup"
})
await send({"type": "websocket.close", "code": 1000})
handler = Mangum(app, enable_lifespan=False)
response = handler(mock_ws_connect_event, {})
assert response == {
"body": "OK",
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"isBase64Encoded": False,
"statusCode": 200,
}
handler = Mangum(app, enable_lifespan=False)
with mock.patch("mangum.protocols.websockets.ASGIWebSocketCycle.send_data"
) as send_data:
send_data.return_value = None
response = handler(mock_ws_send_event, {})
assert response == {
"body": "OK",
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"isBase64Encoded": False,
"statusCode": 200,
}
handler = Mangum(app, enable_lifespan=False)
response = handler(mock_ws_disconnect_event, {})
assert response == {
"body": "OK",
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"isBase64Encoded": False,
"statusCode": 200,
}
"""AWS Lambda handler."""
import logging
from mangum import Mangum
from titiler_digitaltwin.main import app
logging.getLogger("mangum.lifespan").setLevel(logging.ERROR)
logging.getLogger("mangum.http").setLevel(logging.ERROR)
handler = Mangum(app, lifespan="auto", log_level="error")
)
origins = [
"http://localhost:8080",
"http://localhost:8088",
]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
handler = Mangum(app, lifespan="off")
def main():
configure()
uvicorn.run(app, host="127.0.0.1", port=8000, debug=True)
def configure():
configure_routes()
def configure_routes():
app.include_router(api_router, prefix=settings.API_V1_STR)
native_stdout = sys.stdout
native_stderr = sys.stderr
output_buffer = StringIO()
try:
sys.stdout = output_buffer
sys.stderr = output_buffer
if command.get("action") == "migrate":
result = subprocess.check_output(
"python -m alembic upgrade head",
shell=True,
stderr=subprocess.STDOUT,
)
output_buffer.write(_to_native(result))
finally:
sys.stdout = native_stdout
sys.stderr = native_stderr
return {"output": output_buffer.getvalue()}
asgi_handler = Mangum(app)
response = asgi_handler(event, context)
return response
def _to_native(x, charset=sys.getdefaultencoding(), errors="strict"): # noqa
if x is None or isinstance(x, str):
return x
return x.decode(charset, errors)
def test_http_request(mock_http_api_event) -> None:
async def app(scope, receive, send):
assert scope == {
"asgi": {
"version": "3.0"
},
"aws.context": {},
"aws.event": {
"version":
"2.0",
"routeKey":
"$default",
"rawPath":
"/my/path",
"rawQueryString":
mock_http_api_event["rawQueryString"],
"cookies": ["cookie1", "cookie2"],
"headers": {
"accept-encoding": "gzip,deflate",
"x-forwarded-port": "443",
"x-forwarded-proto": "https",
"host": "test.execute-api.us-west-2.amazonaws.com",
},
"queryStringParameters":
mock_http_api_event["queryStringParameters"],
"requestContext": {
"accountId": "123456789012",
"apiId": "api-id",
"authorizer": {
"jwt": {
"claims": {
"claim1": "value1",
"claim2": "value2"
},
"scopes": ["scope1", "scope2"],
}
},
"domainName": "id.execute-api.us-east-1.amazonaws.com",
"domainPrefix": "id",
"http": {
"method": "GET",
"path": "/my/path",
"protocol": "HTTP/1.1",
"sourceIp": "192.168.100.1",
"userAgent": "agent",
},
"requestId": "id",
"routeKey": "$default",
"stage": "$default",
"time": "12/Mar/2020:19:03:58 +0000",
"timeEpoch": 1583348638390,
},
"body":
None,
"pathParameters": {
"parameter1": "value1"
},
"isBase64Encoded":
False,
"stageVariables": {
"stageVariable1": "value1",
"stageVariable2": "value2",
},
},
"client": ("192.168.100.1", 0),
"headers": [
[b"accept-encoding", b"gzip,deflate"],
[b"x-forwarded-port", b"443"],
[b"x-forwarded-proto", b"https"],
[b"host", b"test.execute-api.us-west-2.amazonaws.com"],
],
"http_version":
"1.1",
"method":
"GET",
"path":
"/my/path",
"query_string":
mock_http_api_event["rawQueryString"].encode(),
"raw_path":
None,
"root_path":
"",
"scheme":
"https",
"server": ("test.execute-api.us-west-2.amazonaws.com", 443),
"type":
"http",
}
await send({
"type":
"http.response.start",
"status":
200,
"headers": [[b"content-type", b"text/plain; charset=utf-8"]],
})
await send({"type": "http.response.body", "body": b"Hello, world!"})
handler = Mangum(app, lifespan="off")
response = handler(mock_http_api_event, {})
assert response == {
"statusCode": 200,
"isBase64Encoded": False,
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"body": "Hello, world!",
}
# AWS Lambda & API Gateway. It is intended to provide
# an easy-to-use, configurable wrapper for any ASGI
# application deployed in an AWS Lambda function to
# handle API Gateway requests and responses.
from mangum import Mangum
app = FastAPI(docs_url="/concilcore/files/docs", redoc_url=None)
app.add_middleware(
CORSMiddleware,
allow_origins=['*'],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.include_router(FileRouters)
acquirers_downloads_reports = Mangum(app)
# DB_CONNECTION = Postgres(
# host=environ.get('HOST', 'concildevblackbox.c0rzxyeauhjq.us-east-1.rds.amazonaws.com'),
# database=environ.get('DATABASE', 'concildevblackboxdatabase'),
# user=environ.get('USER', 'awsuser'),
# password=environ.get('PASSWORD', 'Ox!g3n!0'),
# port=environ.get('PORT', 5432)
# )
# def acquirers_downloads_reports(event, context):
# response = {
# "body": {},
# "statusCode": 200
# }
# start_date = event["queryStringParameters"]["start_date"]
)
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.include_router(router)
return app
handler = Mangum(init_app(), log_level="debug")
# if __name__ == "__main__":
# print('Starting migration...')
# try:
# migrate()
# except Exception as ex:
# print(ex)
# print('Done.')
#
# print("Starting app...")
# uvicorn.run(
# init_app(),
# host=settings.APP_HOST,
# port=settings.APP_PORT,
# workers=settings.APP_WORKER_COUNT,
"""AWS Lambda handler.""" from mangum import Mangum from titiler.main import app handler = Mangum(app, enable_lifespan=False, log_level="error")
def test_websocket_events(mock_ws_connect_event, mock_ws_send_event,
mock_ws_disconnect_event, dynamodb) -> None:
table_name = "test-table"
dynamodb.create_table(
TableName=table_name,
KeySchema=[{
"AttributeName": "connectionId",
"KeyType": "HASH"
}],
AttributeDefinitions=[{
"AttributeName": "connectionId",
"AttributeType": "S"
}],
ProvisionedThroughput={
"ReadCapacityUnits": 5,
"WriteCapacityUnits": 5
},
)
async def app(scope, receive, send):
assert scope == {
"client": ["192.168.100.1", 0],
"headers": [
[b"Accept-Encoding", b"gzip, deflate, br"],
[b"Accept-Language", b"en-US,en;q=0.9"],
[b"Cache-Control", b"no-cache"],
[b"Host", b"test.execute-api.ap-southeast-1.amazonaws.com"],
[
b"Origin",
b"https://test.execute-api.ap-southeast-1.amazonaws.com"
],
[b"Pragma", b"no-cache"],
[
b"Sec-WebSocket-Extensions",
b"permessage-deflate; client_max_window_bits",
],
[b"Sec-WebSocket-Key", b"bnfeqmh9SSPr5Sg9DvFIBw=="],
[b"Sec-WebSocket-Version", b"13"],
[
b"User-Agent",
b"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/"
b"537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36",
],
[
b"X-Amzn-Trace-Id",
b"Root=1-5d465cb6-78ddcac1e21f89203d004a89"
],
[b"X-Forwarded-For", b"192.168.100.1"],
[b"X-Forwarded-Port", b"443"],
[b"X-Forwarded-Proto", b"https"],
],
"path":
"/",
"query_string":
b"",
"raw_path":
None,
"root_path":
"Prod",
"scheme":
"https",
"server": ["test.execute-api.ap-southeast-1.amazonaws.com", 80],
"type":
"websocket",
}
await send({"type": "websocket.accept", "subprotocol": None})
await send({"type": "websocket.send", "text": "Hello world!"})
await send({"type": "websocket.send", "bytes": b"Hello world!"})
await send({"type": "websocket.close", "code": 1000})
handler = Mangum(app, enable_lifespan=False)
response = handler(mock_ws_connect_event, {})
assert response == {
"body": "OK",
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"isBase64Encoded": False,
"statusCode": 200,
}
handler = Mangum(app, enable_lifespan=False)
with mock.patch("mangum.protocols.websockets.ASGIWebSocketCycle.send_data"
) as send_data:
send_data.return_value = None
response = handler(mock_ws_send_event, {})
assert response == {
"body": "OK",
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"isBase64Encoded": False,
"statusCode": 200,
}
handler = Mangum(app, enable_lifespan=False)
response = handler(mock_ws_disconnect_event, {})
assert response == {
"body": "OK",
"headers": {
"content-type": "text/plain; charset=utf-8"
},
"isBase64Encoded": False,
"statusCode": 200,
}
request.state.username,
api_name,
item_api_id,
episode_api_id,
review_data_to_dict(data),
)
@app.delete(
"/watch-histories/items/{api_name}/{item_api_id}/episodes/{episode_api_id}",
status_code=204)
def delete_episode(request: Request, api_name: str, item_api_id: str,
episode_api_id: str):
routes.delete_episode(
request.state.username,
api_name,
item_api_id,
episode_api_id,
)
@app.middleware("http")
def parse_token(request: Request, call_next):
auth_header = request.headers.get("authorization")
decoded = jwt.decode(auth_header, options={"verify_signature": False})
request.state.username = decoded["username"]
return call_next(request)
handler = Mangum(app, api_gateway_base_path="/prod")
