id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
5,288 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Header
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
class Header(Param):
"""
A class used internally to represent a header parameter in a path operation.
"""
in_ = ParamTypes.header
def __init__(
self,
default: Any = Undefined,
*,
default_factory: Union[Callable[[], Any], None] = _Unset,
annotation: Optional[Any] = None,
alias: Optional[str] = None,
alias_priority: Union[int, None] = _Unset,
# MAINTENANCE: update when deprecating Pydantic v1, import these types
# str | AliasPath | AliasChoices | None
validation_alias: Union[str, None] = None,
serialization_alias: Union[str, None] = None,
convert_underscores: bool = True,
title: Optional[str] = None,
description: Optional[str] = None,
gt: Optional[float] = None,
ge: Optional[float] = None,
lt: Optional[float] = None,
le: Optional[float] = None,
min_length: Optional[int] = None,
max_length: Optional[int] = None,
pattern: Optional[str] = None,
discriminator: Union[str, None] = None,
strict: Union[bool, None] = _Unset,
multiple_of: Union[float, None] = _Unset,
allow_inf_nan: Union[bool, None] = _Unset,
max_digits: Union[int, None] = _Unset,
decimal_places: Union[int, None] = _Unset,
examples: Optional[List[Any]] = None,
deprecated: Optional[bool] = None,
include_in_schema: bool = True,
json_schema_extra: Union[Dict[str, Any], None] = None,
**extra: Any,
):
"""
Constructs a new Query param.
Parameters
----------
default: Any
The default value of the parameter
default_factory: Callable[[], Any], optional
Callable that will be called when a default value is needed for this field
annotation: Any, optional
The type annotation of the parameter
alias: str, optional
The public name of the field
alias_priority: int, optional
Priority of the alias. This affects whether an alias generator is used
validation_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for validation only
serialization_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for serialization only
convert_underscores: bool
If true convert "_" to "-"
See RFC: https://www.rfc-editor.org/rfc/rfc9110.html#name-field-name-registry
title: str, optional
The title of the parameter
description: str, optional
The description of the parameter
gt: float, optional
Only applies to numbers, required the field to be "greater than"
ge: float, optional
Only applies to numbers, required the field to be "greater than or equal"
lt: float, optional
Only applies to numbers, required the field to be "less than"
le: float, optional
Only applies to numbers, required the field to be "less than or equal"
min_length: int, optional
Only applies to strings, required the field to have a minimum length
max_length: int, optional
Only applies to strings, required the field to have a maximum length
pattern: str, optional
Only applies to strings, requires the field match against a regular expression pattern string
discriminator: str, optional
Parameter field name for discriminating the type in a tagged union
strict: bool, optional
Enables Pydantic's strict mode for the field
multiple_of: float, optional
Only applies to numbers, requires the field to be a multiple of the given value
allow_inf_nan: bool, optional
Only applies to numbers, requires the field to allow infinity and NaN values
max_digits: int, optional
Only applies to Decimals, requires the field to have a maxmium number of digits within the decimal.
decimal_places: int, optional
Only applies to Decimals, requires the field to have at most a number of decimal places
examples: List[Any], optional
A list of examples for the parameter
deprecated: bool, optional
If `True`, the parameter will be marked as deprecated
include_in_schema: bool, optional
If `False`, the parameter will be excluded from the generated OpenAPI schema
json_schema_extra: Dict[str, Any], optional
Extra values to include in the generated OpenAPI schema
"""
self.convert_underscores = convert_underscores
self._alias = alias
super().__init__(
default=default,
default_factory=default_factory,
annotation=annotation,
alias=self._alias,
alias_priority=alias_priority,
validation_alias=validation_alias,
serialization_alias=serialization_alias,
title=title,
description=description,
gt=gt,
ge=ge,
lt=lt,
le=le,
min_length=min_length,
max_length=max_length,
pattern=pattern,
discriminator=discriminator,
strict=strict,
multiple_of=multiple_of,
allow_inf_nan=allow_inf_nan,
max_digits=max_digits,
decimal_places=decimal_places,
deprecated=deprecated,
examples=examples,
include_in_schema=include_in_schema,
json_schema_extra=json_schema_extra,
**extra,
)
def alias(self):
return self._alias
def alias(self, value: Optional[str] = None):
if value is not None:
# Headers are case-insensitive according to RFC 7540 (HTTP/2), so we lower the parameter name
# This ensures that customers can access headers with any casing, as per the RFC guidelines.
# Reference: https://www.rfc-editor.org/rfc/rfc7540#section-8.1.2
self._alias = value.lower()
def get_todos(correlation_id: Annotated[str, Header(min_length=16, max_length=16)]) -> List[Todo]: # (3)!
url = "https://jsonplaceholder.typicode.com/todos"
todo = requests.get(url, headers={"correlation_id": correlation_id})
todo.raise_for_status()
return todo.json() | null |
5,289 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Header
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,290 | import requests
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.models import Contact, Server
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todo_title(todo_id: int) -> str:
todo = requests.get(f"https://jsonplaceholder.typicode.com/todos/{todo_id}")
todo.raise_for_status()
return todo.json()["title"] | null |
5,291 | import requests
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.models import Contact, Server
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,292 | import json
from dataclasses import asdict, dataclass, is_dataclass
from json import JSONEncoder
import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class DataclassCustomEncoder(JSONEncoder):
"""A custom JSON encoder to serialize dataclass obj"""
def default(self, obj):
# Only called for values that aren't JSON serializable
# where `obj` will be an instance of Todo in this example
return asdict(obj) if is_dataclass(obj) else super().default(obj)
The provided code snippet includes necessary dependencies for implementing the `custom_serializer` function. Write a Python function `def custom_serializer(obj) -> str` to solve the following problem:
Your custom serializer function APIGatewayRestResolver will use
Here is the function:
def custom_serializer(obj) -> str:
"""Your custom serializer function APIGatewayRestResolver will use"""
return json.dumps(obj, separators=(",", ":"), cls=DataclassCustomEncoder) | Your custom serializer function APIGatewayRestResolver will use |
5,293 | import json
from dataclasses import asdict, dataclass, is_dataclass
from json import JSONEncoder
import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo:
userId: str
id: str # noqa: A003 VNE003 "id" field is reserved
title: str
completed: bool
def get_todos():
ret: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
ret.raise_for_status()
todos = [Todo(**todo) for todo in ret.json()]
# for brevity, we'll limit to the first 10 only
return {"todos": todos[:10]} | null |
5,294 | import json
from dataclasses import asdict, dataclass, is_dataclass
from json import JSONEncoder
import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
app = APIGatewayRestResolver(serializer=custom_serializer)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,295 | from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_subscription(subscription):
return {"subscription_id": subscription} | null |
5,296 | from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(strip_prefixes=["/payment"])
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,297 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import LambdaFunctionUrlResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
return {"todos": todos.json()[:10]} | null |
5,298 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
logger = Logger()
def log_request_response(app: APIGatewayRestResolver, next_middleware: NextMiddleware) -> Response:
logger.info("Incoming request", path=app.current_event.path, request=app.current_event.raw_event)
result = next_middleware(app)
logger.info("Response received", response=result.__dict__)
return result | null |
5,299 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
logger = Logger()
def inject_correlation_id(app: APIGatewayRestResolver, next_middleware: NextMiddleware) -> Response:
request_id = app.current_event.request_context.request_id
# Use API Gateway REST API request ID if caller didn't include a correlation ID
correlation_id = logger.get_correlation_id() or request_id # elsewhere becomes app.context.get("correlation_id")
# Inject correlation ID in shared context and Logger
app.append_context(correlation_id=correlation_id)
logger.set_correlation_id(correlation_id)
# Get response from next middleware OR /todos route
result = next_middleware(app)
# Include Correlation ID in the response back to caller
result.headers["x-correlation-id"] = correlation_id
return result | null |
5,300 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
def enforce_correlation_id(app: APIGatewayRestResolver, next_middleware: NextMiddleware) -> Response:
# If missing mandatory header raise an error
if not app.current_event.get_header_value("x-correlation-id", case_sensitive=False):
return Response(status_code=400, body="Correlation ID header is now mandatory.") # (1)!
# Get the response from the next middleware and return it
return next_middleware(app) | null |
5,301 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todo_by_id(todo_id: str): # value come as str
todos: Response = requests.get(f"https://jsonplaceholder.typicode.com/todos/{todo_id}")
todos.raise_for_status()
return {"todos": todos.json()} | null |
5,303 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import VPCLatticeResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,304 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import VPCLatticeResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = VPCLatticeResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,305 | from dataclasses import dataclass
import assert_http_api_response_module
import pytest
def lambda_context():
@dataclass
class LambdaContext:
function_name: str = "test"
memory_limit_in_mb: int = 128
invoked_function_arn: str = "arn:aws:lambda:eu-west-1:123456789012:function:test"
aws_request_id: str = "da658bd3-2d6f-4e7b-8ec2-937234644fdc"
return LambdaContext() | null |
5,306 | from dataclasses import dataclass
import assert_http_api_response_module
import pytest
def test_lambda_handler(lambda_context):
minimal_event = {
"rawPath": "/todos",
"requestContext": {
"requestContext": {"requestId": "227b78aa-779d-47d4-a48e-ce62120393b8"}, # correlation ID
"http": {
"method": "GET",
},
"stage": "$default",
},
}
# Example of API Gateway HTTP API request event:
# https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
ret = assert_http_api_response_module.lambda_handler(minimal_event, lambda_context)
assert ret["statusCode"] == 200
assert ret["body"] != "" | null |
5,307 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import ALBResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,308 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import ALBResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = ALBResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,309 | from typing import List
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
userId: int
id_: int = Field(alias="id")
title: str
completed: bool
def create_todo(todo: Todo) -> str:
response = requests.post("https://jsonplaceholder.typicode.com/todos", json=todo.dict(by_alias=True))
response.raise_for_status()
return response.json()["id"] | null |
5,310 | from typing import List
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
userId: int
id_: int = Field(alias="id")
title: str
completed: bool
def get_todos() -> List[Todo]:
todo = requests.get("https://jsonplaceholder.typicode.com/todos")
todo.raise_for_status()
return todo.json() | null |
5,311 | from typing import List
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
app.enable_swagger(path="/swagger")
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,312 | import json
from dataclasses import dataclass
from http import HTTPStatus
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.utilities.typing import LambdaContext
users = [
{
"user_id": "b0b2a5bf-ee1e-4c5e-9a86-91074052739e",
"email": "john.doe@example.com",
"active": True,
},
{
"user_id": "3a9df6b1-938c-4e80-bd4a-0c966f4b1c1e",
"email": "jane.smith@example.com",
"active": False,
},
{
"user_id": "aa0d3d09-9cb9-42b9-9e63-1fb17ea52981",
"email": "alex.wilson@example.com",
"active": True,
},
]
class User:
user_id: str
email: str
active: bool
The provided code snippet includes necessary dependencies for implementing the `all_active_users` function. Write a Python function `def all_active_users()` to solve the following problem:
HTTP Response for all active users
Here is the function:
def all_active_users():
"""HTTP Response for all active users"""
all_users = [User(**user) for user in users]
all_active_users = [user.__dict__ for user in all_users if user.active]
return Response(
status_code=HTTPStatus.OK.value,
content_type="application/json",
body=json.dumps(all_active_users),
) | HTTP Response for all active users |
5,313 | import json
from dataclasses import dataclass
from http import HTTPStatus
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,314 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel): # (2)!
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
def create_todo(todo: Todo) -> str: # (3)!
response = requests.post("https://jsonplaceholder.typicode.com/todos", json=todo.dict(by_alias=True))
response.raise_for_status()
return response.json()["id"] # (4)! | null |
5,315 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel): # (2)!
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
def get_todos() -> List[Todo]:
todo = requests.get("https://jsonplaceholder.typicode.com/todos")
todo.raise_for_status()
return todo.json() # (5)! | null |
5,316 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,317 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.exceptions import (
BadRequestError,
InternalServerError,
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class BadRequestError(ServiceError):
"""API Gateway and ALB Bad Request Error (400)"""
def __init__(self, msg: str):
super().__init__(HTTPStatus.BAD_REQUEST, msg)
def bad_request_error():
raise BadRequestError("Missing required parameter") # HTTP 400 | null |
5,318 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.exceptions import (
BadRequestError,
InternalServerError,
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class UnauthorizedError(ServiceError):
"""API Gateway and ALB Unauthorized Error (401)"""
def __init__(self, msg: str):
super().__init__(HTTPStatus.UNAUTHORIZED, msg)
def unauthorized_error():
raise UnauthorizedError("Unauthorized") # HTTP 401 | null |
5,319 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.exceptions import (
BadRequestError,
InternalServerError,
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class NotFoundError(ServiceError):
"""API Gateway and ALB Not Found Error (404)"""
def __init__(self, msg: str = "Not found"):
super().__init__(HTTPStatus.NOT_FOUND, msg)
def not_found_error():
raise NotFoundError # HTTP 404 | null |
5,320 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.exceptions import (
BadRequestError,
InternalServerError,
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class InternalServerError(ServiceError):
"""API Gateway and ALB Not Found Internal Server Error (500)"""
def __init__(self, message: str):
super().__init__(HTTPStatus.INTERNAL_SERVER_ERROR, message)
def internal_server_error():
raise InternalServerError("Internal server error") # HTTP 500 | null |
5,321 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.exceptions import (
BadRequestError,
InternalServerError,
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class ServiceError(Exception):
"""API Gateway and ALB HTTP Service Error"""
def __init__(self, status_code: int, msg: str):
"""
Parameters
----------
status_code: int
Http status code
msg: str
Error message
"""
self.status_code = status_code
self.msg = msg
def service_error():
raise ServiceError(502, "Something went wrong!") | null |
5,322 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.exceptions import (
BadRequestError,
InternalServerError,
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
return {"todos": todos.json()[:10]} | null |
5,323 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.exceptions import (
BadRequestError,
InternalServerError,
NotFoundError,
ServiceError,
UnauthorizedError,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,324 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
return {"todos": todos.json()[:10]} | null |
5,326 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import BaseMiddlewareHandler, NextMiddleware
def get_todos():
todos: requests.Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,327 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import BaseMiddlewareHandler, NextMiddleware
app = APIGatewayRestResolver()
def lambda_handler(event, context):
return app.resolve(event, context) | null |
5,328 | from typing import Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Path
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
class Path(Param):
"""
A class used internally to represent a path parameter in a path operation.
"""
in_ = ParamTypes.path
def __init__(
self,
default: Any = ...,
*,
default_factory: Union[Callable[[], Any], None] = _Unset,
annotation: Optional[Any] = None,
alias: Optional[str] = None,
alias_priority: Union[int, None] = _Unset,
# MAINTENANCE: update when deprecating Pydantic v1, import these types
# MAINTENANCE: validation_alias: str | AliasPath | AliasChoices | None
validation_alias: Union[str, None] = None,
serialization_alias: Union[str, None] = None,
title: Optional[str] = None,
description: Optional[str] = None,
gt: Optional[float] = None,
ge: Optional[float] = None,
lt: Optional[float] = None,
le: Optional[float] = None,
min_length: Optional[int] = None,
max_length: Optional[int] = None,
pattern: Optional[str] = None,
discriminator: Union[str, None] = None,
strict: Union[bool, None] = _Unset,
multiple_of: Union[float, None] = _Unset,
allow_inf_nan: Union[bool, None] = _Unset,
max_digits: Union[int, None] = _Unset,
decimal_places: Union[int, None] = _Unset,
examples: Optional[List[Any]] = None,
deprecated: Optional[bool] = None,
include_in_schema: bool = True,
json_schema_extra: Union[Dict[str, Any], None] = None,
**extra: Any,
):
"""
Constructs a new Path param.
Parameters
----------
default: Any
The default value of the parameter
default_factory: Callable[[], Any], optional
Callable that will be called when a default value is needed for this field
annotation: Any, optional
The type annotation of the parameter
alias: str, optional
The public name of the field
alias_priority: int, optional
Priority of the alias. This affects whether an alias generator is used
validation_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for validation only
serialization_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for serialization only
title: str, optional
The title of the parameter
description: str, optional
The description of the parameter
gt: float, optional
Only applies to numbers, required the field to be "greater than"
ge: float, optional
Only applies to numbers, required the field to be "greater than or equal"
lt: float, optional
Only applies to numbers, required the field to be "less than"
le: float, optional
Only applies to numbers, required the field to be "less than or equal"
min_length: int, optional
Only applies to strings, required the field to have a minimum length
max_length: int, optional
Only applies to strings, required the field to have a maximum length
pattern: str, optional
Only applies to strings, requires the field match against a regular expression pattern string
discriminator: str, optional
Parameter field name for discriminating the type in a tagged union
strict: bool, optional
Enables Pydantic's strict mode for the field
multiple_of: float, optional
Only applies to numbers, requires the field to be a multiple of the given value
allow_inf_nan: bool, optional
Only applies to numbers, requires the field to allow infinity and NaN values
max_digits: int, optional
Only applies to Decimals, requires the field to have a maxmium number of digits within the decimal.
decimal_places: int, optional
Only applies to Decimals, requires the field to have at most a number of decimal places
examples: List[Any], optional
A list of examples for the parameter
deprecated: bool, optional
If `True`, the parameter will be marked as deprecated
include_in_schema: bool, optional
If `False`, the parameter will be excluded from the generated OpenAPI schema
json_schema_extra: Dict[str, Any], optional
Extra values to include in the generated OpenAPI schema
"""
if default is not ...:
raise AssertionError("Path parameters cannot have a default value")
super(Path, self).__init__(
default=default,
default_factory=default_factory,
annotation=annotation,
alias=alias,
alias_priority=alias_priority,
validation_alias=validation_alias,
serialization_alias=serialization_alias,
title=title,
description=description,
gt=gt,
ge=ge,
lt=lt,
le=le,
min_length=min_length,
max_length=max_length,
pattern=pattern,
discriminator=discriminator,
strict=strict,
multiple_of=multiple_of,
allow_inf_nan=allow_inf_nan,
max_digits=max_digits,
decimal_places=decimal_places,
deprecated=deprecated,
examples=examples,
include_in_schema=include_in_schema,
json_schema_extra=json_schema_extra,
**extra,
)
def get_todo_by_id(todo_id: Annotated[int, Path(lt=999)]) -> Todo: # (1)!
todo = requests.get(f"https://jsonplaceholder.typicode.com/todos/{todo_id}")
todo.raise_for_status()
return todo.json() | null |
5,329 | from typing import Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Path
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,330 | import split_route_append_context_module
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
app.include_router(split_route_append_context_module.router)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
app.append_context(is_admin=True) # arbitrary number of key=value data
return app.resolve(event, context) | null |
5,331 | import requests
from requests import Response
from aws_lambda_powertools.event_handler import ALBResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
app = ALBResolver()
def create_todo():
data: dict = app.current_event.json_body
todo: Response = requests.post("https://jsonplaceholder.typicode.com/todos", data=data)
# Returns the created todo object, with a HTTP 201 Created status
return {"todo": todo.json()}, 201 | null |
5,332 | import requests
from requests import Response
from aws_lambda_powertools.event_handler import ALBResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
app = ALBResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,333 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import ALBResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
return {"todos": todos.json()[:10]} | null |
5,334 | import split_route_module
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
app.include_router(split_route_module.router, prefix="/todos")
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,335 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Query
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
class Query(Param):
"""
A class used internally to represent a query parameter in a path operation.
"""
in_ = ParamTypes.query
def __init__(
self,
default: Any = _Unset,
*,
default_factory: Union[Callable[[], Any], None] = _Unset,
annotation: Optional[Any] = None,
alias: Optional[str] = None,
alias_priority: Union[int, None] = _Unset,
validation_alias: Union[str, None] = None,
serialization_alias: Union[str, None] = None,
title: Optional[str] = None,
description: Optional[str] = None,
gt: Optional[float] = None,
ge: Optional[float] = None,
lt: Optional[float] = None,
le: Optional[float] = None,
min_length: Optional[int] = None,
max_length: Optional[int] = None,
pattern: Optional[str] = None,
discriminator: Union[str, None] = None,
strict: Union[bool, None] = _Unset,
multiple_of: Union[float, None] = _Unset,
allow_inf_nan: Union[bool, None] = _Unset,
max_digits: Union[int, None] = _Unset,
decimal_places: Union[int, None] = _Unset,
examples: Optional[List[Any]] = None,
deprecated: Optional[bool] = None,
include_in_schema: bool = True,
json_schema_extra: Union[Dict[str, Any], None] = None,
**extra: Any,
):
"""
Constructs a new Query param.
Parameters
----------
default: Any
The default value of the parameter
default_factory: Callable[[], Any], optional
Callable that will be called when a default value is needed for this field
annotation: Any, optional
The type annotation of the parameter
alias: str, optional
The public name of the field
alias_priority: int, optional
Priority of the alias. This affects whether an alias generator is used
validation_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for validation only
serialization_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for serialization only
title: str, optional
The title of the parameter
description: str, optional
The description of the parameter
gt: float, optional
Only applies to numbers, required the field to be "greater than"
ge: float, optional
Only applies to numbers, required the field to be "greater than or equal"
lt: float, optional
Only applies to numbers, required the field to be "less than"
le: float, optional
Only applies to numbers, required the field to be "less than or equal"
min_length: int, optional
Only applies to strings, required the field to have a minimum length
max_length: int, optional
Only applies to strings, required the field to have a maximum length
pattern: str, optional
Only applies to strings, requires the field match against a regular expression pattern string
discriminator: str, optional
Parameter field name for discriminating the type in a tagged union
strict: bool, optional
Enables Pydantic's strict mode for the field
multiple_of: float, optional
Only applies to numbers, requires the field to be a multiple of the given value
allow_inf_nan: bool, optional
Only applies to numbers, requires the field to allow infinity and NaN values
max_digits: int, optional
Only applies to Decimals, requires the field to have a maxmium number of digits within the decimal.
decimal_places: int, optional
Only applies to Decimals, requires the field to have at most a number of decimal places
examples: List[Any], optional
A list of examples for the parameter
deprecated: bool, optional
If `True`, the parameter will be marked as deprecated
include_in_schema: bool, optional
If `False`, the parameter will be excluded from the generated OpenAPI schema
json_schema_extra: Dict[str, Any], optional
Extra values to include in the generated OpenAPI schema
"""
super().__init__(
default=default,
default_factory=default_factory,
annotation=annotation,
alias=alias,
alias_priority=alias_priority,
validation_alias=validation_alias,
serialization_alias=serialization_alias,
title=title,
description=description,
gt=gt,
ge=ge,
lt=lt,
le=le,
min_length=min_length,
max_length=max_length,
pattern=pattern,
discriminator=discriminator,
strict=strict,
multiple_of=multiple_of,
allow_inf_nan=allow_inf_nan,
max_digits=max_digits,
decimal_places=decimal_places,
deprecated=deprecated,
examples=examples,
include_in_schema=include_in_schema,
json_schema_extra=json_schema_extra,
**extra,
)
def get_todos(completed: Annotated[Optional[str], Query(min_length=4)] = None) -> List[Todo]: # (3)!
url = "https://jsonplaceholder.typicode.com/todos"
if completed is not None:
url = f"{url}/?completed={completed}"
todo = requests.get(url)
todo.raise_for_status()
return todo.json() | null |
5,336 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Query
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,337 | from enum import Enum
from typing import List
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Header
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
class CountriesAllowed(Enum):
"""Example of an Enum class."""
US = "US"
PT = "PT"
BR = "BR"
class Header(Param):
"""
A class used internally to represent a header parameter in a path operation.
"""
in_ = ParamTypes.header
def __init__(
self,
default: Any = Undefined,
*,
default_factory: Union[Callable[[], Any], None] = _Unset,
annotation: Optional[Any] = None,
alias: Optional[str] = None,
alias_priority: Union[int, None] = _Unset,
# MAINTENANCE: update when deprecating Pydantic v1, import these types
# str | AliasPath | AliasChoices | None
validation_alias: Union[str, None] = None,
serialization_alias: Union[str, None] = None,
convert_underscores: bool = True,
title: Optional[str] = None,
description: Optional[str] = None,
gt: Optional[float] = None,
ge: Optional[float] = None,
lt: Optional[float] = None,
le: Optional[float] = None,
min_length: Optional[int] = None,
max_length: Optional[int] = None,
pattern: Optional[str] = None,
discriminator: Union[str, None] = None,
strict: Union[bool, None] = _Unset,
multiple_of: Union[float, None] = _Unset,
allow_inf_nan: Union[bool, None] = _Unset,
max_digits: Union[int, None] = _Unset,
decimal_places: Union[int, None] = _Unset,
examples: Optional[List[Any]] = None,
deprecated: Optional[bool] = None,
include_in_schema: bool = True,
json_schema_extra: Union[Dict[str, Any], None] = None,
**extra: Any,
):
"""
Constructs a new Query param.
Parameters
----------
default: Any
The default value of the parameter
default_factory: Callable[[], Any], optional
Callable that will be called when a default value is needed for this field
annotation: Any, optional
The type annotation of the parameter
alias: str, optional
The public name of the field
alias_priority: int, optional
Priority of the alias. This affects whether an alias generator is used
validation_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for validation only
serialization_alias: str | AliasPath | AliasChoices | None, optional
Alias to be used for serialization only
convert_underscores: bool
If true convert "_" to "-"
See RFC: https://www.rfc-editor.org/rfc/rfc9110.html#name-field-name-registry
title: str, optional
The title of the parameter
description: str, optional
The description of the parameter
gt: float, optional
Only applies to numbers, required the field to be "greater than"
ge: float, optional
Only applies to numbers, required the field to be "greater than or equal"
lt: float, optional
Only applies to numbers, required the field to be "less than"
le: float, optional
Only applies to numbers, required the field to be "less than or equal"
min_length: int, optional
Only applies to strings, required the field to have a minimum length
max_length: int, optional
Only applies to strings, required the field to have a maximum length
pattern: str, optional
Only applies to strings, requires the field match against a regular expression pattern string
discriminator: str, optional
Parameter field name for discriminating the type in a tagged union
strict: bool, optional
Enables Pydantic's strict mode for the field
multiple_of: float, optional
Only applies to numbers, requires the field to be a multiple of the given value
allow_inf_nan: bool, optional
Only applies to numbers, requires the field to allow infinity and NaN values
max_digits: int, optional
Only applies to Decimals, requires the field to have a maxmium number of digits within the decimal.
decimal_places: int, optional
Only applies to Decimals, requires the field to have at most a number of decimal places
examples: List[Any], optional
A list of examples for the parameter
deprecated: bool, optional
If `True`, the parameter will be marked as deprecated
include_in_schema: bool, optional
If `False`, the parameter will be excluded from the generated OpenAPI schema
json_schema_extra: Dict[str, Any], optional
Extra values to include in the generated OpenAPI schema
"""
self.convert_underscores = convert_underscores
self._alias = alias
super().__init__(
default=default,
default_factory=default_factory,
annotation=annotation,
alias=self._alias,
alias_priority=alias_priority,
validation_alias=validation_alias,
serialization_alias=serialization_alias,
title=title,
description=description,
gt=gt,
ge=ge,
lt=lt,
le=le,
min_length=min_length,
max_length=max_length,
pattern=pattern,
discriminator=discriminator,
strict=strict,
multiple_of=multiple_of,
allow_inf_nan=allow_inf_nan,
max_digits=max_digits,
decimal_places=decimal_places,
deprecated=deprecated,
examples=examples,
include_in_schema=include_in_schema,
json_schema_extra=json_schema_extra,
**extra,
)
def alias(self):
return self._alias
def alias(self, value: Optional[str] = None):
if value is not None:
# Headers are case-insensitive according to RFC 7540 (HTTP/2), so we lower the parameter name
# This ensures that customers can access headers with any casing, as per the RFC guidelines.
# Reference: https://www.rfc-editor.org/rfc/rfc7540#section-8.1.2
self._alias = value.lower()
The provided code snippet includes necessary dependencies for implementing the `get` function. Write a Python function `def get( cloudfront_viewer_country: Annotated[ List[CountriesAllowed], # (1)! Header( description="This is multi value header parameter.", ), ], )` to solve the following problem:
Return validated multi-value header values.
Here is the function:
def get(
cloudfront_viewer_country: Annotated[
List[CountriesAllowed], # (1)!
Header(
description="This is multi value header parameter.",
),
],
):
"""Return validated multi-value header values."""
return cloudfront_viewer_country | Return validated multi-value header values. |
5,338 | from enum import Enum
from typing import List
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Header
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,341 | import json
from dataclasses import dataclass
from http import HTTPStatus
from typing import Union
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_user_by_id(user_id: str) -> Union[User, None]:
for user_data in users:
if user_data["user_id"] == user_id:
return User(
user_id=str(user_data["user_id"]),
email=str(user_data["email"]),
active=bool(user_data["active"]),
)
return None
The provided code snippet includes necessary dependencies for implementing the `all_active_users` function. Write a Python function `def all_active_users(user_id: str)` to solve the following problem:
HTTP Response for all active users
Here is the function:
def all_active_users(user_id: str):
"""HTTP Response for all active users"""
user = get_user_by_id(user_id)
if user:
return Response(
status_code=HTTPStatus.OK.value,
content_type="application/json",
body=json.dumps(user.__dict__),
)
else:
return Response(status_code=HTTPStatus.NOT_FOUND) | HTTP Response for all active users |
5,342 | import json
from dataclasses import dataclass
from http import HTTPStatus
from typing import Union
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,347 | import requests
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todo_title(todo_id: int) -> str:
todo = requests.get(f"https://jsonplaceholder.typicode.com/todos/{todo_id}")
todo.raise_for_status()
return todo.json()["title"] | null |
5,348 | import requests
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,349 | from typing import List
import requests
from pydantic import BaseModel, EmailStr, Field
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
def get_todos_by_email(email: EmailStr) -> List[Todo]:
todos = requests.get(f"https://jsonplaceholder.typicode.com/todos?email={email}")
todos.raise_for_status()
return todos.json() | null |
5,350 | from typing import List
import requests
from pydantic import BaseModel, EmailStr, Field
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
app.enable_swagger(path="/_swagger", swagger_base_url="https://cdn.example.com/path/to/assets/")
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,352 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(debug=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,353 | from dataclasses import dataclass
import assert_rest_api_resolver_response
import pytest
def lambda_context():
@dataclass
class LambdaContext:
function_name: str = "test"
memory_limit_in_mb: int = 128
invoked_function_arn: str = "arn:aws:lambda:eu-west-1:123456789012:function:test"
aws_request_id: str = "da658bd3-2d6f-4e7b-8ec2-937234644fdc"
return LambdaContext() | null |
5,354 | from dataclasses import dataclass
import assert_rest_api_resolver_response
import pytest
import assert_rest_api_resolver_response
def test_lambda_handler(lambda_context):
minimal_event = {
"path": "/todos",
"httpMethod": "GET",
"requestContext": {"requestId": "227b78aa-779d-47d4-a48e-ce62120393b8"}, # correlation ID
}
# Example of API Gateway REST API request event:
# https://docs.aws.amazon.com/lambda/latest/dg/services-apigateway.html#apigateway-example-event
ret = assert_rest_api_resolver_response.lambda_handler(minimal_event, lambda_context)
assert ret["statusCode"] == 200
assert ret["body"] != "" | null |
5,355 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
def get_todos():
endpoint = "https://jsonplaceholder.typicode.com/todos"
api_key: str = app.current_event.get_header_value(name="X-Api-Key", case_sensitive=True, default_value="")
todos: Response = requests.get(endpoint, headers={"X-Api-Key": api_key})
todos.raise_for_status()
return {"todos": todos.json()} | null |
5,357 | import requests
from requests import Response
from aws_lambda_powertools import Tracer
from aws_lambda_powertools.event_handler.api_gateway import Router
router = Router()
endpoint = "https://jsonplaceholder.typicode.com/todos"
def get_todos():
api_key: str = router.current_event.get_header_value(name="X-Api-Key", case_sensitive=True, default_value="")
todos: Response = requests.get(endpoint, headers={"X-Api-Key": api_key})
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,358 | import requests
from requests import Response
from aws_lambda_powertools import Tracer
from aws_lambda_powertools.event_handler.api_gateway import Router
router = Router()
endpoint = "https://jsonplaceholder.typicode.com/todos"
def get_todo_by_id(todo_id: str): # value come as str
api_key: str = router.current_event.get_header_value(
name="X-Api-Key",
case_sensitive=True,
default_value="",
) # sentinel typing # noqa: E501
todos: Response = requests.get(f"{endpoint}/{todo_id}", headers={"X-Api-Key": api_key})
todos.raise_for_status()
return {"todos": todos.json()} | null |
5,359 | import middleware_global_middlewares_module
import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos") # (2)!
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,360 | import middleware_global_middlewares_module
import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
app = APIGatewayRestResolver()
app.use(
middlewares=[
middleware_global_middlewares_module.log_request_response,
middleware_global_middlewares_module.enforce_correlation_id, # (1)!
],
)
def lambda_handler(event, context):
return app.resolve(event, context) | null |
5,361 | from typing import Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Body
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
class Body(FieldInfo):
"""
A class used internally to represent a body parameter in a path operation.
"""
def __init__(
self,
default: Any = Undefined,
*,
default_factory: Union[Callable[[], Any], None] = _Unset,
annotation: Optional[Any] = None,
embed: bool = False,
media_type: str = "application/json",
alias: Optional[str] = None,
alias_priority: Union[int, None] = _Unset,
# MAINTENANCE: update when deprecating Pydantic v1, import these types
# str | AliasPath | AliasChoices | None
validation_alias: Union[str, None] = None,
serialization_alias: Union[str, None] = None,
title: Optional[str] = None,
description: Optional[str] = None,
gt: Optional[float] = None,
ge: Optional[float] = None,
lt: Optional[float] = None,
le: Optional[float] = None,
min_length: Optional[int] = None,
max_length: Optional[int] = None,
pattern: Optional[str] = None,
discriminator: Union[str, None] = None,
strict: Union[bool, None] = _Unset,
multiple_of: Union[float, None] = _Unset,
allow_inf_nan: Union[bool, None] = _Unset,
max_digits: Union[int, None] = _Unset,
decimal_places: Union[int, None] = _Unset,
examples: Optional[List[Any]] = None,
deprecated: Optional[bool] = None,
include_in_schema: bool = True,
json_schema_extra: Union[Dict[str, Any], None] = None,
**extra: Any,
):
self.embed = embed
self.media_type = media_type
self.deprecated = deprecated
self.include_in_schema = include_in_schema
kwargs = dict(
default=default,
default_factory=default_factory,
alias=alias,
title=title,
description=description,
gt=gt,
ge=ge,
lt=lt,
le=le,
min_length=min_length,
max_length=max_length,
discriminator=discriminator,
multiple_of=multiple_of,
allow_nan=allow_inf_nan,
max_digits=max_digits,
decimal_places=decimal_places,
**extra,
)
if examples is not None:
kwargs["examples"] = examples
current_json_schema_extra = json_schema_extra or extra
if PYDANTIC_V2:
kwargs.update(
{
"annotation": annotation,
"alias_priority": alias_priority,
"validation_alias": validation_alias,
"serialization_alias": serialization_alias,
"strict": strict,
"json_schema_extra": current_json_schema_extra,
"pattern": pattern,
},
)
else:
kwargs["regex"] = pattern
kwargs.update(**current_json_schema_extra)
use_kwargs = {k: v for k, v in kwargs.items() if v is not _Unset}
super().__init__(**use_kwargs)
def __repr__(self) -> str:
return f"{self.__class__.__name__}({self.default})"
def create_todo(todo: Annotated[Todo, Body(embed=True)]) -> int: # (2)!
response = requests.post("https://jsonplaceholder.typicode.com/todos", json=todo.dict(by_alias=True))
response.raise_for_status()
return response.json()["id"] | null |
5,362 | from typing import Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.openapi.params import Body
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,363 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
logger = Logger()
def inject_correlation_id(app: APIGatewayRestResolver, next_middleware: NextMiddleware) -> Response:
request_id = app.current_event.request_context.request_id # (1)!
# Use API Gateway REST API request ID if caller didn't include a correlation ID
correlation_id = logger.get_correlation_id() or request_id # (2)!
# Inject correlation ID in shared context and Logger
app.append_context(correlation_id=correlation_id) # (3)!
logger.set_correlation_id(correlation_id)
# Get response from next middleware OR /todos route
result = next_middleware(app) # (4)!
# Include Correlation ID in the response back to caller
result.headers["x-correlation-id"] = correlation_id # (5)!
return result | null |
5,364 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
def get_todos():
todos: Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,365 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
app = APIGatewayRestResolver()
def lambda_handler(event, context):
return app.resolve(event, context) | null |
5,366 | from typing import List, Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel):
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
def get_todos(completed: Optional[str] = None) -> List[Todo]: # (1)!
url = "https://jsonplaceholder.typicode.com/todos"
if completed is not None:
url = f"{url}/?completed={completed}"
todo = requests.get(url)
todo.raise_for_status()
return todo.json() | null |
5,368 | import requests
from requests import Response
from aws_lambda_powertools import Tracer
from aws_lambda_powertools.event_handler.api_gateway import Router
router = Router()
endpoint = "https://jsonplaceholder.typicode.com/todos"
def get_todos():
is_admin: bool = router.context.get("is_admin", False)
todos = {}
if is_admin:
todos: Response = requests.get(endpoint)
todos.raise_for_status()
todos = todos.json()[:10]
# for brevity, we'll limit to the first 10 only
return {"todos": todos} | null |
5,369 | from typing import Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(BaseModel): # (2)!
userId: int
id_: Optional[int] = Field(alias="id", default=None)
title: str
completed: bool
def get_todo_by_id(todo_id: int) -> Todo: # (4)!
todo = requests.get(f"https://jsonplaceholder.typicode.com/todos/{todo_id}")
todo.raise_for_status()
return todo.json() # (5)! | null |
5,370 | from typing import Optional
import requests
from pydantic import BaseModel, Field
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,372 | import requests
from requests import Response
from aws_lambda_powertools import Tracer
from aws_lambda_powertools.event_handler.api_gateway import Router
router = Router()
endpoint = "https://jsonplaceholder.typicode.com/todos"
def get_todo_by_id(todo_id: str): # value come as str
api_key: str = router.current_event.get_header_value(
name="X-Api-Key",
case_sensitive=True,
default_value="",
) # noqa: E501
todos: Response = requests.get(f"{endpoint}/{todo_id}", headers={"X-Api-Key": api_key})
todos.raise_for_status()
return {"todos": todos.json()} | null |
5,373 | import requests
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import (
APIGatewayRestResolver,
Response,
content_types,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_todos():
todos: requests.Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return Response(status_code=200, content_type=content_types.APPLICATION_JSON, body=todos.json()[:10], compress=True) | null |
5,375 | import re
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
def get_subscription(subscription):
return {"subscription_id": subscription} | null |
5,376 | import re
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(strip_prefixes=[re.compile(r"/v[1-3]+/(dev|stg|qa)")])
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,377 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.data_classes import VPCLatticeEvent, event_source
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: VPCLatticeEvent, context: LambdaContext):
logger.info(event.body)
response = {
"isBase64Encoded": False,
"statusCode": 200,
"headers": {"Content-Type": "application/text"},
"body": "Event Response to VPC Lattice 🔥🚀🔥",
}
return response | null |
5,378 | from json import JSONDecodeError
from typing import Dict
from aws_lambda_powertools.utilities.data_classes import (
KinesisFirehoseDataTransformationRecord,
KinesisFirehoseDataTransformationResponse,
KinesisFirehoseEvent,
event_source,
)
from aws_lambda_powertools.utilities.serialization import base64_from_json
from aws_lambda_powertools.utilities.typing import LambdaContext
def base64_from_json(data: Any, json_serializer: Callable[..., str] = json.dumps) -> str:
def lambda_handler(event: KinesisFirehoseEvent, context: LambdaContext):
result = KinesisFirehoseDataTransformationResponse()
for record in event.records:
try:
payload: Dict = record.data_as_json # decodes and deserialize base64 JSON string
## generate data to return
transformed_data = {"tool_used": "powertools_dataclass", "original_payload": payload}
processed_record = KinesisFirehoseDataTransformationRecord(
record_id=record.record_id,
data=base64_from_json(transformed_data),
)
except JSONDecodeError: # (1)!
# our producers ingest JSON payloads only; drop malformed records from the stream
processed_record = KinesisFirehoseDataTransformationRecord(
record_id=record.record_id,
data=record.data,
result="Dropped",
)
result.add_record(processed_record)
# return transformed records
return result.asdict() | null |
5,379 | from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.data_classes import SecretsManagerEvent, event_source
secrets_provider = parameters.SecretsProvider()
def lambda_handler(event: SecretsManagerEvent, context):
# Getting secret value using Parameter utility
# See https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/
secret = secrets_provider.get(event.secret_id, VersionId=event.version_id, VersionStage="AWSCURRENT")
# You need to work with secrets afterwards
# Check more examples: https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas
return secret | null |
5,380 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.data_classes import CloudWatchAlarmEvent, event_source
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: CloudWatchAlarmEvent, context: LambdaContext) -> dict:
logger.info(f"Alarm {event.alarm_data.alarm_name} state is {event.alarm_data.state.value}")
# You can now work with event. For example, you can enrich the received data, and
# decide on how you want to route the alarm.
return {
"name": event.alarm_data.alarm_name,
"arn": event.alarm_arn,
"urgent": "Priority: P1" in (event.alarm_data.configuration.description or ""),
} | null |
5,381 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.data_classes import (
AWSConfigRuleEvent,
event_source,
)
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: AWSConfigRuleEvent, context: LambdaContext):
message_type = event.invoking_event.message_type
logger.info(f"Logging {message_type} event rule", invoke_event=event.raw_invoking_event)
return {"Success": "OK"} | null |
5,382 | from aws_lambda_powertools.utilities.data_classes import (
KinesisFirehoseDataTransformationResponse,
KinesisFirehoseEvent,
event_source,
)
from aws_lambda_powertools.utilities.serialization import base64_from_json
from aws_lambda_powertools.utilities.typing import LambdaContext
def base64_from_json(data: Any, json_serializer: Callable[..., str] = json.dumps) -> str:
"""Encode JSON serializable data as base64 string
Parameters
----------
data: Any
JSON serializable (dict, list, boolean, etc.)
json_serializer: Callable
function to serialize `obj` to a JSON formatted `str`, by default json.dumps
Returns
-------
str:
JSON string as base64 string
"""
return base64_from_str(data=json_serializer(data))
def lambda_handler(event: KinesisFirehoseEvent, context: LambdaContext):
result = KinesisFirehoseDataTransformationResponse()
for record in event.records:
# get original data using data_as_text property
data = record.data_as_text # (1)!
## generate data to return
transformed_data = {"new_data": "transformed data using Powertools", "original_payload": data}
processed_record = record.build_data_transformation_response(
data=base64_from_json(transformed_data), # (2)!
)
result.add_record(processed_record)
# return transformed records
return result.asdict() | null |
5,383 | from aws_lambda_powertools.utilities.data_classes import (
KinesisFirehoseDataTransformationRecord,
KinesisFirehoseDataTransformationResponse,
KinesisFirehoseEvent,
event_source,
)
from aws_lambda_powertools.utilities.serialization import base64_from_json
from aws_lambda_powertools.utilities.typing import LambdaContext
def base64_from_json(data: Any, json_serializer: Callable[..., str] = json.dumps) -> str:
"""Encode JSON serializable data as base64 string
Parameters
----------
data: Any
JSON serializable (dict, list, boolean, etc.)
json_serializer: Callable
function to serialize `obj` to a JSON formatted `str`, by default json.dumps
Returns
-------
str:
JSON string as base64 string
"""
return base64_from_str(data=json_serializer(data))
def lambda_handler(event: dict, context: LambdaContext):
firehose_event = KinesisFirehoseEvent(event)
result = KinesisFirehoseDataTransformationResponse()
for record in firehose_event.records:
try:
payload = record.data_as_text # base64 decoded data as str
# generate data to return
transformed_data = {"tool_used": "powertools_dataclass", "original_payload": payload}
# Default result is Ok
processed_record = KinesisFirehoseDataTransformationRecord(
record_id=record.record_id,
data=base64_from_json(transformed_data),
)
except Exception:
# add Failed result to processing results, send back to kinesis for retry
processed_record = KinesisFirehoseDataTransformationRecord(
record_id=record.record_id,
data=record.data,
result="ProcessingFailed", # (1)!
)
result.add_record(processed_record)
# return transformed records
return result.asdict() | null |
5,384 | from aws_lambda_powertools.utilities.data_classes import (
CodePipelineJobEvent,
event_source,
)
def lambda_handler(event, context):
print(event) | null |
5,385 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.data_classes import VPCLatticeEventV2, event_source
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: VPCLatticeEventV2, context: LambdaContext):
logger.info(event.body)
response = {
"isBase64Encoded": False,
"statusCode": 200,
"statusDescription": "200 OK",
"headers": {"Content-Type": "application/text"},
"body": "VPC Lattice V2 Event ✨🎉✨",
}
return response | null |
5,386 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.data_classes import BedrockAgentEvent, event_source
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: BedrockAgentEvent, context: LambdaContext) -> dict:
input_text = event.input_text
logger.info(f"Bedrock Agent {event.action_group} invoked with input", input_text=input_text)
return {
"message_version": "1.0",
"responses": [
{
"action_group": event.action_group,
"api_path": event.api_path,
"http_method": event.http_method,
"http_status_code": 200,
"response_body": {"application/json": {"body": "This is the response"}},
},
],
} | null |
5,387 | import boto3
from botocore.exceptions import ClientError
from aws_lambda_powertools.utilities.data_classes import S3BatchOperationEvent, S3BatchOperationResponse, event_source
from aws_lambda_powertools.utilities.typing import LambdaContext
def do_some_work(s3_client, src_bucket: str, src_key: str):
def lambda_handler(event: S3BatchOperationEvent, context: LambdaContext):
response = S3BatchOperationResponse(event.invocation_schema_version, event.invocation_id, "PermanentFailure")
task = event.task
src_key: str = task.s3_key
src_bucket: str = task.s3_bucket
s3 = boto3.client("s3", region_name="us-east-1")
try:
dest_bucket, dest_key = do_some_work(s3, src_bucket, src_key)
result = task.build_task_batch_response("Succeeded", f"s3://{dest_bucket}/{dest_key}")
except ClientError as e:
error_code = e.response["Error"]["Code"]
error_message = e.response["Error"]["Message"]
if error_code == "RequestTimeout":
result = task.build_task_batch_response("TemporaryFailure", "Retry request to Amazon S3 due to timeout.")
else:
result = task.build_task_batch_response("PermanentFailure", f"{error_code}: {error_message}")
except Exception as e:
result = task.build_task_batch_response("PermanentFailure", str(e))
finally:
response.add_result(result)
return response.asdict() | null |
5,388 | import json
from pydantic import BaseModel, validator
from aws_lambda_powertools.utilities.parser import event_parser
from aws_lambda_powertools.utilities.parser.models import APIGatewayProxyEventV2Model
from aws_lambda_powertools.utilities.typing import LambdaContext
class CancelOrder(BaseModel):
order_id: int
reason: str
class CancelOrderModel(APIGatewayProxyEventV2Model):
body: CancelOrder # type: ignore[assignment]
def transform_body_to_dict(cls, value: str):
return json.loads(value)
def handler(event: CancelOrderModel, context: LambdaContext):
cancel_order: CancelOrder = event.body
assert cancel_order.order_id is not None | null |
5,390 | from pydantic import BaseModel, Json
from aws_lambda_powertools.utilities.parser import event_parser
from aws_lambda_powertools.utilities.parser.models import APIGatewayProxyEventV2Model
from aws_lambda_powertools.utilities.typing import LambdaContext
class CancelOrder(BaseModel):
class CancelOrderModel(APIGatewayProxyEventV2Model): # type: ignore[assignment]
def handler(event: CancelOrderModel, context: LambdaContext):
cancel_order: CancelOrder = event.body
assert cancel_order.order_id is not None | null |
5,391 | from typing import List
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler.appsync import Router
from aws_lambda_powertools.shared.types import TypedDict
class Location(TypedDict, total=False):
id: str # noqa AA03 VNE003, required due to GraphQL Schema
name: str
description: str
address: str
def get_locations(name: str, description: str = "") -> List[Location]: # match GraphQL Query arguments
return [{"name": name, "description": description}] | null |
5,392 | import asyncio
from typing import List
import aiohttp
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import AppSyncResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import TypedDict
from aws_lambda_powertools.tracing import aiohttp_trace_config
from aws_lambda_powertools.utilities.typing import LambdaContext
class Todo(TypedDict, total=False):
async def list_todos() -> List[Todo]:
async with aiohttp.ClientSession(trace_configs=[aiohttp_trace_config()]) as session:
async with session.get("https://jsonplaceholder.typicode.com/todos") as resp:
return await resp.json() | null |
5,393 | import asyncio
from typing import List
import aiohttp
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import AppSyncResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import TypedDict
from aws_lambda_powertools.tracing import aiohttp_trace_config
from aws_lambda_powertools.utilities.typing import LambdaContext
app = AppSyncResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
result = app.resolve(event, context)
return asyncio.run(result) | null |
5,394 | from typing import List
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import AppSyncResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import TypedDict
from aws_lambda_powertools.utilities.typing import LambdaContext
class Location(TypedDict, total=False):
def get_locations(name: str, description: str = "") -> List[Location]: # match GraphQL Query arguments
return [{"name": name, "description": description}] | null |
5,395 | from typing import List
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import AppSyncResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import TypedDict
from aws_lambda_powertools.utilities.typing import LambdaContext
app = AppSyncResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,396 | import split_operation_append_context_module
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import AppSyncResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = AppSyncResolver()
app.include_router(split_operation_append_context_module.router)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
app.append_context(is_admin=True) # arbitrary number of key=value data
return app.resolve(event, context) | null |
5,397 | from typing import List
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import AppSyncResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.shared.types import TypedDict
from aws_lambda_powertools.utilities.typing import LambdaContext
class Location(TypedDict, total=False):
id: str # noqa AA03 VNE003, required due to GraphQL Schema
name: str
description: str
address: str
def get_locations(name: str, description: str = "") -> List[Location]: # match GraphQL Query arguments
return [{"name": name, "description": description}] | null |
5,399 | import json
from dataclasses import dataclass
from pathlib import Path
from typing import List
import pytest
from assert_async_graphql_response_module import ( # instance of AppSyncResolver
Todo,
app,
)
def lambda_context():
@dataclass
class LambdaContext:
function_name: str = "test"
memory_limit_in_mb: int = 128
invoked_function_arn: str = "arn:aws:lambda:eu-west-1:123456789012:function:test"
aws_request_id: str = "da658bd3-2d6f-4e7b-8ec2-937234644fdc"
return LambdaContext() | null |
5,400 | import json
from dataclasses import dataclass
from pathlib import Path
from typing import List
import pytest
from assert_async_graphql_response_module import ( # instance of AppSyncResolver
Todo,
app,
)
app = AppSyncResolver()
async def test_async_direct_resolver(lambda_context):
# GIVEN
fake_event = json.loads(Path("assert_async_graphql_response.json").read_text())
# WHEN
result: List[Todo] = await app(fake_event, lambda_context)
# alternatively, you can also run a sync test against `lambda_handler`
# since `lambda_handler` awaits the coroutine to complete
# THEN
assert result[0]["userId"] == 1
assert result[0]["id"] == 1
assert result[0]["completed"] is False | null |
5,401 | from typing import List
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler.appsync import Router
from aws_lambda_powertools.shared.types import TypedDict
router = Router()
class Location(TypedDict, total=False):
id: str # noqa AA03 VNE003, required due to GraphQL Schema
name: str
description: str
address: str
def get_locations(name: str, description: str = "") -> List[Location]: # match GraphQL Query arguments
is_admin: bool = router.context.get("is_admin", False)
return [{"name": name, "description": description}] if is_admin else [] | null |
5,402 | import split_operation_module
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import AppSyncResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = AppSyncResolver()
app.include_router(split_operation_module.router)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.