%global _empty_manifest_terminate_build 0
Name: python-pylambdarest
Version: 0.2.1
Release: 1
Summary: Lightweight framework for building REST API using AWS Lambda + API Gateway
License: MIT
URL: https://github.com/MarwanDebbiche/pylambdarest
Source0: https://mirrors.aliyun.com/pypi/web/packages/c1/5b/2ebd216e671a48e72b9c6255996cfb661fa288e5cdd7b70bd85c91ee6cad/pylambdarest-0.2.1.tar.gz
BuildArch: noarch
Requires: python3-jsonschema
Requires: python3-PyJWT
Requires: python3-simplejson
%description
# pylambdarest
[](https://github.com/MarwanDebbiche/pylambdarest/actions?query=branch:master)
[](https://coveralls.io/github/MarwanDebbiche/pylambdarest?branch=master)
[](https://pypi.python.org/pypi/pylambdarest)
[](https://pypi.org/project/pylambdarest/)
pylambdarest is a lightweight opinionated framework for building REST API using [AWS Lambda](https://aws.amazon.com/lambda/) and [API Gateway](https://aws.amazon.com/api-gateway/).
## Motivation
Why another framework ?
When using API Gateway and python Lambda functions, the most common pattern is to have a unique Lambda function triggered by a proxy API Gateway resource. The Lambda then uses a framework like [Flask](https://flask.palletsprojects.com/en/1.1.x/) to do all the routing. In an API Gateway + Lambda context, I feel like **the routing should be handled by API Gateway itself**, then forwarding the request to specific Lambda functions for each resource or endpoint.
## Features
- No routing. Yes, this is a feature. Routing should be handled by API Gateway.
- API Gateway event parsing (including request body and path parameters).
- Cleaner syntax.
- Optional body schema and query parameters validation.
## Installation
Install the package from PyPI using pip:
```
$ pip install pylambdarest
```
pylambdarest should also be included in the deployment package of your Lambda functions.
## Getting started
pylambdarest provides a `@route` decorator to parse the API Gateway event into a `Request` object available in the handler function as an argument. It also formats the handler's output to the expected Lambda + API Gateway format seamlessly.
Turning this:
```python
import json
def handler(event, context):
body = json.loads(event["body"])
query_params = event["queryStringParameters"]
path_params = event["pathParameters"]
return {
"statusCode": 200,
"body": json.dumps({
"message": f"Hello from AWS Lambda {body['name']}!!"
})
}
```
Into this:
```python
from pylambdarest import route
@route()
def handler(request):
body = request.json
query_params = request.query_params
path_params = request.path_params
return 200, {"message": f"Hello from AWS Lambda {body['name']}!!"}
```
You can still access the original `event` and `context` arguments from the handler:
```python
from pylambdarest import route
@route()
def handler(request, event, context):
print(event)
body = request.json
return 200, {"message": f"Hello from AWS Lambda {body['name']}!!"}
```
Path parameters defined in API Gateway can also be accessed directly as function argument:
```python
from pylambdarest import route
@route()
def get_user(user_id):
print(user_id)
# get user from db
user = {"id": user_id, "name": "John Doe"}
return 200, user
```
## Schema Validation
pylambdarest optionally provides schema validation using [jsonschema](https://github.com/Julian/jsonschema):
```python
from pylambdarest import route
user_schema = {
"type": "object",
"properties": {
"name": {"type": "string"}
},
"required": ["name"],
"additionalProperties": False
}
@route(body_schema=user_schema)
def create_user(request):
# If the request's body does not
# satisfy the user_schema,
# a 400 will be returned
# Create user here
return 201
query_params_schema = {
"type": "object",
"properties": {
# Only string types are allowed for query parameters.
# Types casting should be done in the handler.
"page": {"type": "string"}
},
"additionalProperties": False
}
@route(query_params_schema=query_params_schema)
def get_users(request):
page = int(request.query_params.get("page", 1))
# request users in db
users = [
{"userId": i}
for i in range((page - 1) * 50, page * 50)
]
return 200, users
```
## Example
You can look at the [sample](https://github.com/MarwanDebbiche/pylambdarest/tree/master/sample) for a minimal pylambdarest API.
In this sample, we use the [serverless](https://www.serverless.com/) framework to declare the API Gateway -> Lambda routing
The packaging of the Lambda functions is done using the [serverless-python-requirements](https://github.com/UnitedIncome/serverless-python-requirements) plugin.
%package -n python3-pylambdarest
Summary: Lightweight framework for building REST API using AWS Lambda + API Gateway
Provides: python-pylambdarest
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-pylambdarest
# pylambdarest
[](https://github.com/MarwanDebbiche/pylambdarest/actions?query=branch:master)
[](https://coveralls.io/github/MarwanDebbiche/pylambdarest?branch=master)
[](https://pypi.python.org/pypi/pylambdarest)
[](https://pypi.org/project/pylambdarest/)
pylambdarest is a lightweight opinionated framework for building REST API using [AWS Lambda](https://aws.amazon.com/lambda/) and [API Gateway](https://aws.amazon.com/api-gateway/).
## Motivation
Why another framework ?
When using API Gateway and python Lambda functions, the most common pattern is to have a unique Lambda function triggered by a proxy API Gateway resource. The Lambda then uses a framework like [Flask](https://flask.palletsprojects.com/en/1.1.x/) to do all the routing. In an API Gateway + Lambda context, I feel like **the routing should be handled by API Gateway itself**, then forwarding the request to specific Lambda functions for each resource or endpoint.
## Features
- No routing. Yes, this is a feature. Routing should be handled by API Gateway.
- API Gateway event parsing (including request body and path parameters).
- Cleaner syntax.
- Optional body schema and query parameters validation.
## Installation
Install the package from PyPI using pip:
```
$ pip install pylambdarest
```
pylambdarest should also be included in the deployment package of your Lambda functions.
## Getting started
pylambdarest provides a `@route` decorator to parse the API Gateway event into a `Request` object available in the handler function as an argument. It also formats the handler's output to the expected Lambda + API Gateway format seamlessly.
Turning this:
```python
import json
def handler(event, context):
body = json.loads(event["body"])
query_params = event["queryStringParameters"]
path_params = event["pathParameters"]
return {
"statusCode": 200,
"body": json.dumps({
"message": f"Hello from AWS Lambda {body['name']}!!"
})
}
```
Into this:
```python
from pylambdarest import route
@route()
def handler(request):
body = request.json
query_params = request.query_params
path_params = request.path_params
return 200, {"message": f"Hello from AWS Lambda {body['name']}!!"}
```
You can still access the original `event` and `context` arguments from the handler:
```python
from pylambdarest import route
@route()
def handler(request, event, context):
print(event)
body = request.json
return 200, {"message": f"Hello from AWS Lambda {body['name']}!!"}
```
Path parameters defined in API Gateway can also be accessed directly as function argument:
```python
from pylambdarest import route
@route()
def get_user(user_id):
print(user_id)
# get user from db
user = {"id": user_id, "name": "John Doe"}
return 200, user
```
## Schema Validation
pylambdarest optionally provides schema validation using [jsonschema](https://github.com/Julian/jsonschema):
```python
from pylambdarest import route
user_schema = {
"type": "object",
"properties": {
"name": {"type": "string"}
},
"required": ["name"],
"additionalProperties": False
}
@route(body_schema=user_schema)
def create_user(request):
# If the request's body does not
# satisfy the user_schema,
# a 400 will be returned
# Create user here
return 201
query_params_schema = {
"type": "object",
"properties": {
# Only string types are allowed for query parameters.
# Types casting should be done in the handler.
"page": {"type": "string"}
},
"additionalProperties": False
}
@route(query_params_schema=query_params_schema)
def get_users(request):
page = int(request.query_params.get("page", 1))
# request users in db
users = [
{"userId": i}
for i in range((page - 1) * 50, page * 50)
]
return 200, users
```
## Example
You can look at the [sample](https://github.com/MarwanDebbiche/pylambdarest/tree/master/sample) for a minimal pylambdarest API.
In this sample, we use the [serverless](https://www.serverless.com/) framework to declare the API Gateway -> Lambda routing
The packaging of the Lambda functions is done using the [serverless-python-requirements](https://github.com/UnitedIncome/serverless-python-requirements) plugin.
%package help
Summary: Development documents and examples for pylambdarest
Provides: python3-pylambdarest-doc
%description help
# pylambdarest
[](https://github.com/MarwanDebbiche/pylambdarest/actions?query=branch:master)
[](https://coveralls.io/github/MarwanDebbiche/pylambdarest?branch=master)
[](https://pypi.python.org/pypi/pylambdarest)
[](https://pypi.org/project/pylambdarest/)
pylambdarest is a lightweight opinionated framework for building REST API using [AWS Lambda](https://aws.amazon.com/lambda/) and [API Gateway](https://aws.amazon.com/api-gateway/).
## Motivation
Why another framework ?
When using API Gateway and python Lambda functions, the most common pattern is to have a unique Lambda function triggered by a proxy API Gateway resource. The Lambda then uses a framework like [Flask](https://flask.palletsprojects.com/en/1.1.x/) to do all the routing. In an API Gateway + Lambda context, I feel like **the routing should be handled by API Gateway itself**, then forwarding the request to specific Lambda functions for each resource or endpoint.
## Features
- No routing. Yes, this is a feature. Routing should be handled by API Gateway.
- API Gateway event parsing (including request body and path parameters).
- Cleaner syntax.
- Optional body schema and query parameters validation.
## Installation
Install the package from PyPI using pip:
```
$ pip install pylambdarest
```
pylambdarest should also be included in the deployment package of your Lambda functions.
## Getting started
pylambdarest provides a `@route` decorator to parse the API Gateway event into a `Request` object available in the handler function as an argument. It also formats the handler's output to the expected Lambda + API Gateway format seamlessly.
Turning this:
```python
import json
def handler(event, context):
body = json.loads(event["body"])
query_params = event["queryStringParameters"]
path_params = event["pathParameters"]
return {
"statusCode": 200,
"body": json.dumps({
"message": f"Hello from AWS Lambda {body['name']}!!"
})
}
```
Into this:
```python
from pylambdarest import route
@route()
def handler(request):
body = request.json
query_params = request.query_params
path_params = request.path_params
return 200, {"message": f"Hello from AWS Lambda {body['name']}!!"}
```
You can still access the original `event` and `context` arguments from the handler:
```python
from pylambdarest import route
@route()
def handler(request, event, context):
print(event)
body = request.json
return 200, {"message": f"Hello from AWS Lambda {body['name']}!!"}
```
Path parameters defined in API Gateway can also be accessed directly as function argument:
```python
from pylambdarest import route
@route()
def get_user(user_id):
print(user_id)
# get user from db
user = {"id": user_id, "name": "John Doe"}
return 200, user
```
## Schema Validation
pylambdarest optionally provides schema validation using [jsonschema](https://github.com/Julian/jsonschema):
```python
from pylambdarest import route
user_schema = {
"type": "object",
"properties": {
"name": {"type": "string"}
},
"required": ["name"],
"additionalProperties": False
}
@route(body_schema=user_schema)
def create_user(request):
# If the request's body does not
# satisfy the user_schema,
# a 400 will be returned
# Create user here
return 201
query_params_schema = {
"type": "object",
"properties": {
# Only string types are allowed for query parameters.
# Types casting should be done in the handler.
"page": {"type": "string"}
},
"additionalProperties": False
}
@route(query_params_schema=query_params_schema)
def get_users(request):
page = int(request.query_params.get("page", 1))
# request users in db
users = [
{"userId": i}
for i in range((page - 1) * 50, page * 50)
]
return 200, users
```
## Example
You can look at the [sample](https://github.com/MarwanDebbiche/pylambdarest/tree/master/sample) for a minimal pylambdarest API.
In this sample, we use the [serverless](https://www.serverless.com/) framework to declare the API Gateway -> Lambda routing
The packaging of the Lambda functions is done using the [serverless-python-requirements](https://github.com/UnitedIncome/serverless-python-requirements) plugin.
%prep
%autosetup -n pylambdarest-0.2.1
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-pylambdarest -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Tue Jun 20 2023 Python_Bot - 0.2.1-1
- Package Spec generated