id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
5,184 | from typing import Any
import requests
from botocore.config import Config
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
appconf_provider = parameters.AppConfigProvider(environment="dev", application="comments", config=config)
def lambda_handler(event: dict, context: LambdaContext):
try:
# Retrieve a single parameter
endpoint_comments: Any = appconf_provider.get("config", transform="json")
# the value of this parameter is https://jsonplaceholder.typicode.com/comments/
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10], "statusCode": 200}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,185 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext):
try:
# Retrieve a single parameter with 20s cache
endpoint_comments: Any = parameters.get_parameter("/lambda-powertools/endpoint_comments", force_fetch=True)
# the value of this parameter is https://jsonplaceholder.typicode.com/comments/
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10], "statusCode": 200}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,186 | from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
secrets_provider = parameters.SecretsProvider()
def lambda_handler(event: dict, context: LambdaContext):
# The 'VersionId' argument will be passed to the underlying get_secret_value() call.
value = secrets_provider.get("my-secret", VersionId="e62ec170-6b01-48c7-94f3-d7497851a8d2")
return value | null |
5,187 | from __future__ import annotations
from typing import Any
from aws_lambda_powertools.utilities.parameters.ssm import get_parameters_by_name
parameters = {
"/develop/service/commons/telemetry/config": {"max_age": 300, "transform": "json"},
# it would fail by default
"/this/param/does/not/exist": {},
}
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: None = None,
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Dict[str, str]:
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: Literal["binary"],
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Dict[str, bytes]:
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: Literal["json"],
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Dict[str, Dict[str, Any]]:
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: Literal["auto"],
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Union[Dict[str, str], Dict[str, dict]]:
def get_parameters_by_name(
parameters: Dict[str, Any],
transform: TransformOptions = None,
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Union[Dict[str, str], Dict[str, bytes], Dict[str, dict]]:
def handler(event, context):
values: dict[str, Any] = get_parameters_by_name(parameters=parameters, raise_on_error=False)
errors: list[str] = values.get("_errors", [])
# Handle gracefully, since '/this/param/does/not/exist' will only be available in `_errors`
if errors:
...
for parameter, value in values.items():
print(f"{parameter}: {value}") | null |
5,188 | import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext) -> dict:
try:
# Retrieve a single parameter
endpoint_comments = parameters.get_parameter("/lambda-powertools/endpoint_comments")
# the value of this parameter is https://jsonplaceholder.typicode.com/comments/
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10], "statusCode": 200}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,189 | from __future__ import annotations
from typing import Any
from aws_lambda_powertools.utilities.parameters.ssm import get_parameters_by_name
parameters = {
"/develop/service/commons/telemetry/config": {"max_age": 300, "transform": "json"},
"/no_cache_param": {"max_age": 0},
# inherit default values
"/develop/service/payment/api/capture/url": {},
}
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: None = None,
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Dict[str, str]: ...
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: Literal["binary"],
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Dict[str, bytes]: ...
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: Literal["json"],
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Dict[str, Dict[str, Any]]: ...
def get_parameters_by_name(
parameters: Dict[str, Dict],
transform: Literal["auto"],
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Union[Dict[str, str], Dict[str, dict]]: ...
def get_parameters_by_name(
parameters: Dict[str, Any],
transform: TransformOptions = None,
decrypt: Optional[bool] = None,
max_age: Optional[int] = None,
raise_on_error: bool = True,
) -> Union[Dict[str, str], Dict[str, bytes], Dict[str, dict]]:
"""
Retrieve multiple parameter values by name from AWS Systems Manager (SSM) Parameter Store
Parameters
----------
parameters: List[Dict[str, Dict]]
List of parameter names, and any optional overrides
transform: str, optional
Transforms the content from a JSON object ('json') or base64 binary string ('binary')
decrypt: bool, optional
If the parameter values should be decrypted
max_age: int, optional
Maximum age of the cached value
raise_on_error: bool, optional
Whether to fail-fast or fail gracefully by including "_errors" key in the response, by default True
Example
-------
**Retrieves multiple parameters from distinct paths from Systems Manager Parameter Store**
from aws_lambda_powertools.utilities.parameters import get_parameters_by_name
params = {
"/param": {},
"/json": {"transform": "json"},
"/binary": {"transform": "binary"},
"/no_cache": {"max_age": 0},
"/api_key": {"decrypt": True},
}
values = get_parameters_by_name(parameters=params)
for param_name, value in values.items():
print(f"{param_name}: {value}")
# "/param": value
# "/json": value
# "/binary": value
# "/no_cache": value
# "/api_key": value
Raises
------
GetParameterError
When the parameter provider fails to retrieve a parameter value for
a given name.
"""
# NOTE: Decided against using multi-thread due to single-thread outperforming in 128M and 1G + timeout risk
# see: https://github.com/aws-powertools/powertools-lambda-python/issues/1040#issuecomment-1299954613
# If max_age is not set, resolve it from the environment variable, defaulting to DEFAULT_MAX_AGE_SECS
max_age = resolve_max_age(env=os.getenv(constants.PARAMETERS_MAX_AGE_ENV, DEFAULT_MAX_AGE_SECS), choice=max_age)
# If decrypt is not set, resolve it from the environment variable, defaulting to False
decrypt = resolve_truthy_env_var_choice(
env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"),
choice=decrypt,
)
# Only create the provider if this function is called at least once
if "ssm" not in DEFAULT_PROVIDERS:
DEFAULT_PROVIDERS["ssm"] = SSMProvider()
return DEFAULT_PROVIDERS["ssm"].get_parameters_by_name(
parameters=parameters,
max_age=max_age,
transform=transform,
decrypt=decrypt,
raise_on_error=raise_on_error,
)
def handler(event, context):
# This returns a dict with the parameter name as key
response: dict[str, Any] = get_parameters_by_name(parameters=parameters, max_age=60)
for parameter, value in response.items():
print(f"{parameter}: {value}") | null |
5,190 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext):
try:
# Retrieve a single parameter
endpoint_comments: Any = parameters.get_app_config(
name="config",
environment="dev",
application="comments",
max_age=20,
)
# the value of this parameter is https://jsonplaceholder.typicode.com/comments/
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10], "statusCode": 200}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,191 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext):
try:
# Usually an endpoint is not sensitive data, so we store it in SSM Parameters
endpoint_comments: Any = parameters.get_parameter("/lambda-powertools/endpoint_comments")
# An API-KEY is a sensitive data and should be stored in SecretsManager
api_key: Any = parameters.get_secret("/lambda-powertools/api-key", max_age=20)
headers: dict = {"X-API-Key": api_key}
comments: requests.Response = requests.get(endpoint_comments, headers=headers)
return {"comments": comments.json()[:10], "statusCode": 200}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,192 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext):
try:
# Usually an endpoint is not sensitive data, so we store it in SSM Parameters
endpoint_comments: Any = parameters.get_parameter("/lambda-powertools/endpoint_comments")
# An API-KEY is a sensitive data and should be stored in SecretsManager
api_key: Any = parameters.get_secret("/lambda-powertools/api-key", force_fetch=True)
headers: dict = {"X-API-Key": api_key}
comments: requests.Response = requests.get(endpoint_comments, headers=headers)
return {"comments": comments.json()[:10], "statusCode": 200}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,193 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext):
try:
# Retrieve multiple parameters from a path prefix
all_parameters: Any = parameters.get_parameters("/lambda-powertools/", max_age=20)
endpoint_comments = "https://jsonplaceholder.typicode.com/noexists/"
for parameter, value in all_parameters.items():
if parameter == "endpoint_comments":
endpoint_comments = value
# the value of parameter is https://jsonplaceholder.typicode.com/comments/
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10]}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,194 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
dynamodb_provider = parameters.DynamoDBProvider(table_name="ParameterTable")
def lambda_handler(event: dict, context: LambdaContext):
try:
# Usually an endpoint is not sensitive data, so we store it in DynamoDB Table
endpoint_comments: Any = dynamodb_provider.get("comments_endpoint")
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10], "statusCode": 200}
# general exception
except Exception as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,195 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext):
try:
# Retrieve multiple parameters from a path prefix
all_parameters: Any = parameters.get_parameters("/lambda-powertools/", force_fetch=True)
endpoint_comments = "https://jsonplaceholder.typicode.com/noexists/"
for parameter, value in all_parameters.items():
if parameter == "endpoint_comments":
endpoint_comments = value
# the value of parameter is https://jsonplaceholder.typicode.com/comments/
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10]}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,196 | from typing import Any
import boto3
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
ssm_provider = parameters.SSMProvider(boto3_session=boto3_session)
def lambda_handler(event: dict, context: LambdaContext):
try:
# Retrieve multiple parameters from a path prefix
all_parameters: Any = ssm_provider.get_multiple("/lambda-powertools/")
endpoint_comments = "https://jsonplaceholder.typicode.com/noexists/"
for parameter, value in all_parameters.items():
if parameter == "endpoint_comments":
endpoint_comments = value
# the value of parameter is https://jsonplaceholder.typicode.com/comments/
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10]}
except parameters.exceptions.GetParameterError as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,197 | from typing import Any
import requests
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
dynamodb_provider = parameters.DynamoDBProvider(
table_name="ParameterTable",
key_attr="IdKeyAttr",
sort_attr="SkKeyAttr",
value_attr="ValueAttr",
)
def lambda_handler(event: dict, context: LambdaContext):
try:
# Usually an endpoint is not sensitive data, so we store it in DynamoDB Table
endpoint_comments: Any = dynamodb_provider.get("comments_endpoint")
comments: requests.Response = requests.get(endpoint_comments)
return {"comments": comments.json()[:10], "statusCode": 200}
# general exception
except Exception as error:
return {"comments": None, "message": str(error), "statusCode": 400} | null |
5,198 | from typing import Any
from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
The provided code snippet includes necessary dependencies for implementing the `lambda_handler` function. Write a Python function `def lambda_handler(event: dict, context: LambdaContext)` to solve the following problem:
This feature flag is enabled under the following conditions: - The request payload contains a field 'tier' with the value 'premium'. Rule condition to be evaluated: "conditions": [ { "action": "EQUALS", "key": "tier", "value": "premium" } ]
Here is the function:
def lambda_handler(event: dict, context: LambdaContext):
"""
This feature flag is enabled under the following conditions:
- The request payload contains a field 'tier' with the value 'premium'.
Rule condition to be evaluated:
"conditions": [
{
"action": "EQUALS",
"key": "tier",
"value": "premium"
}
]
"""
# Get customer's tier from incoming request
ctx = {"tier": event.get("tier", "standard")}
# Evaluate whether customer's tier has access to premium features
# based on `has_premium_features` rules
has_premium_features: Any = feature_flags.evaluate(name="premium_features", context=ctx, default=False)
if has_premium_features:
# enable premium features
... | This feature flag is enabled under the following conditions: - The request payload contains a field 'tier' with the value 'premium'. Rule condition to be evaluated: "conditions": [ { "action": "EQUALS", "key": "tier", "value": "premium" } ] |
5,199 | from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
The provided code snippet includes necessary dependencies for implementing the `lambda_handler` function. Write a Python function `def lambda_handler(event: dict, context: LambdaContext)` to solve the following problem:
This non-boolean feature flag returns the percentage discount depending on the sale experiment segment: - 10% standard discount if the user_id belongs to the spectrum 0-3 modulo 10, (40% users). - 15% experiment discount if the user_id belongs to the spectrum 4-6 modulo 10, (30% users). - 18% experiment discount if the user_id belongs to the spectrum 7-9 modulo 10, (30% users). Rule conditions to be evaluated: "rules": { "control group - standard 10% discount segment": { "when_match": 10, "conditions": [ { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 10, "START": 0, "END": 3 } } ] }, "test experiment 1 - 15% discount segment": { "when_match": 15, "conditions": [ { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 10, "START": 4, "END": 6 } } ] }, "test experiment 2 - 18% discount segment": { "when_match": 18, "conditions": [ { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 10, "START": 7, "END": 9 } } ] } }
Here is the function:
def lambda_handler(event: dict, context: LambdaContext):
"""
This non-boolean feature flag returns the percentage discount depending on the sale experiment segment:
- 10% standard discount if the user_id belongs to the spectrum 0-3 modulo 10, (40% users).
- 15% experiment discount if the user_id belongs to the spectrum 4-6 modulo 10, (30% users).
- 18% experiment discount if the user_id belongs to the spectrum 7-9 modulo 10, (30% users).
Rule conditions to be evaluated:
"rules": {
"control group - standard 10% discount segment": {
"when_match": 10,
"conditions": [
{
"action": "MODULO_RANGE",
"key": "user_id",
"value": {
"BASE": 10,
"START": 0,
"END": 3
}
}
]
},
"test experiment 1 - 15% discount segment": {
"when_match": 15,
"conditions": [
{
"action": "MODULO_RANGE",
"key": "user_id",
"value": {
"BASE": 10,
"START": 4,
"END": 6
}
}
]
},
"test experiment 2 - 18% discount segment": {
"when_match": 18,
"conditions": [
{
"action": "MODULO_RANGE",
"key": "user_id",
"value": {
"BASE": 10,
"START": 7,
"END": 9
}
}
]
}
}
"""
# Get customer's tier and identifier from incoming request
ctx = {"tier": event.get("tier", "standard"), "user_id": event.get("user_id", 0)}
# Get sale discount percentage from feature flag.
sale_experiment_discount = feature_flags.evaluate(name="sale_experiment_discount", default=0, context=ctx)
return {"message": f" {sale_experiment_discount}% discount applied."} | This non-boolean feature flag returns the percentage discount depending on the sale experiment segment: - 10% standard discount if the user_id belongs to the spectrum 0-3 modulo 10, (40% users). - 15% experiment discount if the user_id belongs to the spectrum 4-6 modulo 10, (30% users). - 18% experiment discount if the user_id belongs to the spectrum 7-9 modulo 10, (30% users). Rule conditions to be evaluated: "rules": { "control group - standard 10% discount segment": { "when_match": 10, "conditions": [ { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 10, "START": 0, "END": 3 } } ] }, "test experiment 1 - 15% discount segment": { "when_match": 15, "conditions": [ { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 10, "START": 4, "END": 6 } } ] }, "test experiment 2 - 18% discount segment": { "when_match": 18, "conditions": [ { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 10, "START": 7, "END": 9 } } ] } } |
5,200 | from __future__ import annotations
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
feature_flags = FeatureFlags(store=app_config)
def list_products():
# getting fields from request
# https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/#accessing-request-details
json_body = app.current_event.json_body
headers = app.current_event.headers
ctx = {**headers, **json_body}
# getting price from payload
price: float = float(json_body.get("price"))
percent_discount: int = 0
# all_features is evaluated to ["premium_features", "geo_customer_campaign", "ten_percent_off_campaign"]
all_features: list[str] = feature_flags.get_enabled_features(context=ctx)
if "geo_customer_campaign" in all_features:
# apply 20% discounts for customers in NL
percent_discount += 20
if "ten_percent_off_campaign" in all_features:
# apply additional 10% for all customers
percent_discount += 10
price = price * (100 - percent_discount) / 100
return {"price": price} | null |
5,201 | from __future__ import annotations
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver()
def lambda_handler(event: dict, context: LambdaContext):
return app.resolve(event, context) | null |
5,202 | from typing import Any
from custom_s3_store_provider import S3StoreProvider
from aws_lambda_powertools.utilities.feature_flags import FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=s3_config_store)
def lambda_handler(event: dict, context: LambdaContext):
apply_discount: Any = feature_flags.evaluate(name="ten_percent_off_campaign", default=False)
price: Any = event.get("price")
if apply_discount:
# apply 10% discount to product
price = price * 0.9
return {"price": price} | null |
5,203 | from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
The provided code snippet includes necessary dependencies for implementing the `lambda_handler` function. Write a Python function `def lambda_handler(event: dict, context: LambdaContext)` to solve the following problem:
This feature flag is enabled under the following conditions: - The request payload contains a field 'tier' with the value 'premium'. - If the current day is either Saturday or Sunday in America/New_York timezone. Rule condition to be evaluated: "conditions": [ { "action": "EQUALS", "key": "tier", "value": "premium" }, { "action": "SCHEDULE_BETWEEN_DAYS_OF_WEEK", "key": "CURRENT_DAY_OF_WEEK", "value": { "DAYS": [ "SATURDAY", "SUNDAY" ], "TIMEZONE": "America/New_York" } } ]
Here is the function:
def lambda_handler(event: dict, context: LambdaContext):
"""
This feature flag is enabled under the following conditions:
- The request payload contains a field 'tier' with the value 'premium'.
- If the current day is either Saturday or Sunday in America/New_York timezone.
Rule condition to be evaluated:
"conditions": [
{
"action": "EQUALS",
"key": "tier",
"value": "premium"
},
{
"action": "SCHEDULE_BETWEEN_DAYS_OF_WEEK",
"key": "CURRENT_DAY_OF_WEEK",
"value": {
"DAYS": [
"SATURDAY",
"SUNDAY"
],
"TIMEZONE": "America/New_York"
}
}
]
"""
# Get customer's tier from incoming request
ctx = {"tier": event.get("tier", "standard")}
# Checking if the weekend premum discount is enable
weekend_premium_discount = feature_flags.evaluate(name="weekend_premium_discount", default=False, context=ctx)
if weekend_premium_discount:
# Enable special discount on weekend for premium users:
return {"message": "The weekend premium discount is enabled."}
return {"message": "The weekend premium discount is not enabled."} | This feature flag is enabled under the following conditions: - The request payload contains a field 'tier' with the value 'premium'. - If the current day is either Saturday or Sunday in America/New_York timezone. Rule condition to be evaluated: "conditions": [ { "action": "EQUALS", "key": "tier", "value": "premium" }, { "action": "SCHEDULE_BETWEEN_DAYS_OF_WEEK", "key": "CURRENT_DAY_OF_WEEK", "value": { "DAYS": [ "SATURDAY", "SUNDAY" ], "TIMEZONE": "America/New_York" } } ] |
5,204 | from typing import Any
from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
def lambda_handler(event: dict, context: LambdaContext):
# Get customer's tier from incoming request
ctx = {"tier": event.get("tier", "standard")}
# Evaluate `has_premium_features` based on customer's tier
premium_features: Any = feature_flags.evaluate(name="premium_features", context=ctx, default=[])
return {"Premium features enabled": premium_features} | null |
5,205 | from typing import Any
from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
def lambda_handler(event: dict, context: LambdaContext):
apply_discount: Any = feature_flags.evaluate(name="ten_percent_off_campaign", default=False)
price: Any = event.get("price")
if apply_discount:
# apply 10% discount to product
price = price * 0.9
return {"price": price} | null |
5,206 | from typing import Any
from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
The provided code snippet includes necessary dependencies for implementing the `lambda_handler` function. Write a Python function `def lambda_handler(event: dict, context: LambdaContext)` to solve the following problem:
This feature flag is enabled by default for all requests.
Here is the function:
def lambda_handler(event: dict, context: LambdaContext):
"""
This feature flag is enabled by default for all requests.
"""
apply_discount: Any = feature_flags.evaluate(name="ten_percent_off_campaign", default=False)
price: Any = event.get("price")
if apply_discount:
# apply 10% discount to product
price = price * 0.9
return {"price": price} | This feature flag is enabled by default for all requests. |
5,207 | from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
The provided code snippet includes necessary dependencies for implementing the `lambda_handler` function. Write a Python function `def lambda_handler(event: dict, context: LambdaContext)` to solve the following problem:
This feature flag is enabled under the following conditions: - Start date: December 25th, 2022 at 12:00:00 PM EST - End date: December 31st, 2022 at 11:59:59 PM EST - Timezone: America/New_York Rule condition to be evaluated: "conditions": [ { "action": "SCHEDULE_BETWEEN_DATETIME_RANGE", "key": "CURRENT_DATETIME", "value": { "START": "2022-12-25T12:00:00", "END": "2022-12-31T23:59:59", "TIMEZONE": "America/New_York" } } ]
Here is the function:
def lambda_handler(event: dict, context: LambdaContext):
"""
This feature flag is enabled under the following conditions:
- Start date: December 25th, 2022 at 12:00:00 PM EST
- End date: December 31st, 2022 at 11:59:59 PM EST
- Timezone: America/New_York
Rule condition to be evaluated:
"conditions": [
{
"action": "SCHEDULE_BETWEEN_DATETIME_RANGE",
"key": "CURRENT_DATETIME",
"value": {
"START": "2022-12-25T12:00:00",
"END": "2022-12-31T23:59:59",
"TIMEZONE": "America/New_York"
}
}
]
"""
# Checking if the Christmas discount is enable
xmas_discount = feature_flags.evaluate(name="christmas_discount", default=False)
if xmas_discount:
# Enable special discount on christmas:
return {"message": "The Christmas discount is enabled."}
return {"message": "The Christmas discount is not enabled."} | This feature flag is enabled under the following conditions: - Start date: December 25th, 2022 at 12:00:00 PM EST - End date: December 31st, 2022 at 11:59:59 PM EST - Timezone: America/New_York Rule condition to be evaluated: "conditions": [ { "action": "SCHEDULE_BETWEEN_DATETIME_RANGE", "key": "CURRENT_DATETIME", "value": { "START": "2022-12-25T12:00:00", "END": "2022-12-31T23:59:59", "TIMEZONE": "America/New_York" } } ] |
5,208 | from typing import Any
from botocore.config import Config
from jmespath.functions import Functions, signature
from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
def lambda_handler(event: dict, context: LambdaContext):
apply_discount: Any = feature_flags.evaluate(name="ten_percent_off_campaign", default=False)
price: Any = event.get("price")
if apply_discount:
# apply 10% discount to product
price = price * 0.9
return {"price": price} | null |
5,210 | from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
The provided code snippet includes necessary dependencies for implementing the `lambda_handler` function. Write a Python function `def lambda_handler(event: dict, context: LambdaContext)` to solve the following problem:
This feature flag is enabled under the following conditions: - The request payload contains a field 'tier' with the value 'standard'. - If the user_id belongs to the spectrum 0-19 modulo 100, (20% users) on whom we want to run the sale experiment. Rule condition to be evaluated: "conditions": [ { "action": "EQUALS", "key": "tier", "value": "standard" }, { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 100, "START": 0, "END": 19 } } ]
Here is the function:
def lambda_handler(event: dict, context: LambdaContext):
"""
This feature flag is enabled under the following conditions:
- The request payload contains a field 'tier' with the value 'standard'.
- If the user_id belongs to the spectrum 0-19 modulo 100, (20% users) on whom we want to run the sale experiment.
Rule condition to be evaluated:
"conditions": [
{
"action": "EQUALS",
"key": "tier",
"value": "standard"
},
{
"action": "MODULO_RANGE",
"key": "user_id",
"value": {
"BASE": 100,
"START": 0,
"END": 19
}
}
]
"""
# Get customer's tier and identifier from incoming request
ctx = {"tier": event.get("tier", "standard"), "user_id": event.get("user_id", 0)}
# Checking if the sale_experiment is enable
sale_experiment = feature_flags.evaluate(name="sale_experiment", default=False, context=ctx)
if sale_experiment:
# Enable special discount for sale experiment segment users:
return {"message": "The sale experiment is enabled."}
return {"message": "The sale experiment is not enabled."} | This feature flag is enabled under the following conditions: - The request payload contains a field 'tier' with the value 'standard'. - If the user_id belongs to the spectrum 0-19 modulo 100, (20% users) on whom we want to run the sale experiment. Rule condition to be evaluated: "conditions": [ { "action": "EQUALS", "key": "tier", "value": "standard" }, { "action": "MODULO_RANGE", "key": "user_id", "value": { "BASE": 100, "START": 0, "END": 19 } } ] |
5,211 | from aws_lambda_powertools.utilities.feature_flags import AppConfigStore, FeatureFlags
from aws_lambda_powertools.utilities.typing import LambdaContext
feature_flags = FeatureFlags(store=app_config)
The provided code snippet includes necessary dependencies for implementing the `lambda_handler` function. Write a Python function `def lambda_handler(event: dict, context: LambdaContext)` to solve the following problem:
This feature flag is enabled under the following conditions: - Every day between 17:00 to 19:00 in Europe/Copenhagen timezone Rule condition to be evaluated: "conditions": [ { "action": "SCHEDULE_BETWEEN_TIME_RANGE", "key": "CURRENT_TIME", "value": { "START": "17:00", "END": "19:00", "TIMEZONE": "Europe/Copenhagen" } } ]
Here is the function:
def lambda_handler(event: dict, context: LambdaContext):
"""
This feature flag is enabled under the following conditions:
- Every day between 17:00 to 19:00 in Europe/Copenhagen timezone
Rule condition to be evaluated:
"conditions": [
{
"action": "SCHEDULE_BETWEEN_TIME_RANGE",
"key": "CURRENT_TIME",
"value": {
"START": "17:00",
"END": "19:00",
"TIMEZONE": "Europe/Copenhagen"
}
}
]
"""
# Checking if the happy hour discount is enable
is_happy_hour = feature_flags.evaluate(name="happy_hour", default=False)
if is_happy_hour:
# Enable special discount on happy hour:
return {"message": "The happy hour discount is enabled."}
return {"message": "The happy hour discount is not enabled."} | This feature flag is enabled under the following conditions: - Every day between 17:00 to 19:00 in Europe/Copenhagen timezone Rule condition to be evaluated: "conditions": [ { "action": "SCHEDULE_BETWEEN_TIME_RANGE", "key": "CURRENT_TIME", "value": { "START": "17:00", "END": "19:00", "TIMEZONE": "Europe/Copenhagen" } } ] |
5,212 | import getting_started_validator_standalone_schema as schemas
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate
ALLOWED_IPS = parameters.get_parameter("/lambda-powertools/allowed_ips")
def lambda_handler(event, context: LambdaContext) -> dict:
try:
user_authenticated: str = ""
# using standalone function to validate input data only
validate(event=event, schema=schemas.INPUT)
if (
event.get("user_id") == "0d44b083-8206-4a3a-aa95-5d392a99be4a"
and event.get("project") == "powertools"
and event.get("ip") in ALLOWED_IPS
):
user_authenticated = "Allowed"
# in this example the body can be of any type because we are not validating the OUTPUT
return {"body": user_authenticated, "statusCode": 200 if user_authenticated else 204}
except SchemaValidationError as exception:
# SchemaValidationError indicates where a data mismatch is
return {"body": str(exception), "statusCode": 400} | null |
5,213 | import boto3
import unwrapping_popular_event_source_schema as schemas
from botocore.exceptions import ClientError
from aws_lambda_powertools.utilities.data_classes.event_bridge_event import (
EventBridgeEvent,
)
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.utilities.validation import envelopes, validator
class EventBridgeEvent(DictWrapper):
"""Amazon EventBridge Event
Documentation:
--------------
- https://docs.aws.amazon.com/eventbridge/latest/userguide/aws-events.html
"""
def get_id(self) -> str:
"""A unique value is generated for every event. This can be helpful in tracing events as
they move through rules to targets, and are processed."""
# Note: this name conflicts with existing python builtins
return self["id"]
def version(self) -> str:
"""By default, this is set to 0 (zero) in all events."""
return self["version"]
def account(self) -> str:
"""The 12-digit number identifying an AWS account."""
return self["account"]
def time(self) -> str:
"""The event timestamp, which can be specified by the service originating the event.
If the event spans a time interval, the service might choose to report the start time, so
this value can be noticeably before the time the event is actually received.
"""
return self["time"]
def region(self) -> str:
"""Identifies the AWS region where the event originated."""
return self["region"]
def resources(self) -> List[str]:
"""This JSON array contains ARNs that identify resources that are involved in the event.
Inclusion of these ARNs is at the discretion of the service."""
return self["resources"]
def source(self) -> str:
"""Identifies the service that sourced the event. All events sourced from within AWS begin with "aws." """
return self["source"]
def detail_type(self) -> str:
"""Identifies, in combination with the source field, the fields and values that appear in the detail field."""
return self["detail-type"]
def detail(self) -> Dict[str, Any]:
"""A JSON object, whose content is at the discretion of the service originating the event."""
return self["detail"]
def replay_name(self) -> Optional[str]:
"""Identifies whether the event is being replayed and what is the name of the replay."""
return self["replay-name"]
def lambda_handler(event: dict, context: LambdaContext) -> dict:
my_event = EventBridgeEvent(event)
ec2_client = boto3.resource("ec2", region_name=my_event.region)
try:
instance_id = my_event.detail.get("instance_id")
instance = ec2_client.Instance(instance_id)
instance.stop()
return {"message": f"Successfully stopped {instance_id}", "success": True}
except ClientError as exception:
return {"message": str(exception), "success": False} | null |
5,214 | from dataclasses import dataclass, field
from uuid import uuid4
import getting_started_validator_decorator_schema as schemas
from aws_lambda_powertools.utilities import parameters
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.utilities.validation import validator
ALLOWED_IPS = parameters.get_parameter("/lambda-powertools/allowed_ips")
class UserPermissionsError(Exception):
...
class User:
ip: str
permissions: list
user_id: str = field(default_factory=lambda: f"{uuid4()}")
name: str = "Project Lambda Powertools"
def lambda_handler(event, context: LambdaContext) -> dict:
try:
user_details: dict = {}
# get permissions by user_id and project
if (
event.get("user_id") == "0d44b083-8206-4a3a-aa95-5d392a99be4a"
and event.get("project") == "powertools"
and event.get("ip") in ALLOWED_IPS
):
user_details = User(ip=event.get("ip"), permissions=["read", "write"]).__dict__
# the body must be an object because must match OUTPUT schema, otherwise it fails
return {"body": user_details or None, "statusCode": 200 if user_details else 204}
except Exception as e:
raise UserPermissionsError(str(e)) | null |
5,215 | import json
import re
import boto3
import custom_format_schema as schemas
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate
custom_format = {"awsaccountid": lambda value: re.match(r"^(\d{12})$", value)}
def return_error_message(message: str) -> dict:
return {"account": None, "message": message, "statusCode": 400}
def lambda_handler(event, context: LambdaContext) -> dict:
try:
# validate input using custom json format
validate(event=event, schema=schemas.INPUT, formats=custom_format)
client_organization = boto3.client("organizations", region_name=event.get("region"))
account_data = client_organization.describe_account(AccountId=event.get("accountid"))
return {
"account": json.dumps(account_data.get("Account"), default=str),
"message": "Success",
"statusCode": 200,
}
except SchemaValidationError as exception:
return return_error_message(str(exception))
except Exception as exception:
return return_error_message(str(exception)) | null |
5,216 | import boto3
import getting_started_validator_unwrapping_schema as schemas
from aws_lambda_powertools.utilities.data_classes.event_bridge_event import (
EventBridgeEvent,
)
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.utilities.validation import validator
s3_client = boto3.resource("s3")
def return_error_message(message: str) -> dict:
return {"message": message, "success": False}
def process_data_object(content: str) -> str:
# insert logic here
return "Data OK"
class EventBridgeEvent(DictWrapper):
"""Amazon EventBridge Event
Documentation:
--------------
- https://docs.aws.amazon.com/eventbridge/latest/userguide/aws-events.html
"""
def get_id(self) -> str:
"""A unique value is generated for every event. This can be helpful in tracing events as
they move through rules to targets, and are processed."""
# Note: this name conflicts with existing python builtins
return self["id"]
def version(self) -> str:
"""By default, this is set to 0 (zero) in all events."""
return self["version"]
def account(self) -> str:
"""The 12-digit number identifying an AWS account."""
return self["account"]
def time(self) -> str:
"""The event timestamp, which can be specified by the service originating the event.
If the event spans a time interval, the service might choose to report the start time, so
this value can be noticeably before the time the event is actually received.
"""
return self["time"]
def region(self) -> str:
"""Identifies the AWS region where the event originated."""
return self["region"]
def resources(self) -> List[str]:
"""This JSON array contains ARNs that identify resources that are involved in the event.
Inclusion of these ARNs is at the discretion of the service."""
return self["resources"]
def source(self) -> str:
"""Identifies the service that sourced the event. All events sourced from within AWS begin with "aws." """
return self["source"]
def detail_type(self) -> str:
"""Identifies, in combination with the source field, the fields and values that appear in the detail field."""
return self["detail-type"]
def detail(self) -> Dict[str, Any]:
"""A JSON object, whose content is at the discretion of the service originating the event."""
return self["detail"]
def replay_name(self) -> Optional[str]:
"""Identifies whether the event is being replayed and what is the name of the replay."""
return self["replay-name"]
def lambda_handler(event: dict, context: LambdaContext) -> dict:
my_event = EventBridgeEvent(event)
data = my_event.detail.get("data", {})
s3_bucket, s3_key = data.get("s3_bucket"), data.get("s3_key")
try:
s3_object = s3_client.Object(bucket_name=s3_bucket, key=s3_key)
payload = s3_object.get()["Body"]
content = payload.read().decode("utf-8")
return {"message": process_data_object(content), "success": True}
except s3_client.meta.client.exceptions.NoSuchBucket as exception:
return return_error_message(str(exception))
except s3_client.meta.client.exceptions.NoSuchKey as exception:
return return_error_message(str(exception)) | null |
5,217 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
logger.debug(f"Correlation ID => {logger.get_correlation_id()}")
logger.info("Collecting payment")
return "hello world" | null |
5,218 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
fields = {"request_id": "1123"}
logger.info("Collecting payment", extra=fields)
return "hello world" | null |
5,219 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger(service="payment", sample_rate=0.1)
def lambda_handler(event: dict, context: LambdaContext):
logger.debug("Verifying whether order_id is present")
logger.info("Collecting payment")
return "hello world" | null |
5,220 | from logger_reuse_payment import inject_payment_id
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def inject_payment_id(context):
logger.append_keys(payment_id=context.get("payment_id"))
def lambda_handler(event: dict, context: LambdaContext) -> str:
inject_payment_id(context=event)
logger.info("Collecting payment")
return "hello world" | null |
5,221 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
ENDPOINT = "http://httpbin.org/status/500"
logger = Logger(serialize_stacktrace=True)
def lambda_handler(event: dict, context: LambdaContext) -> str:
try:
ret = requests.get(ENDPOINT)
ret.raise_for_status()
except requests.HTTPError as e:
logger.exception(e)
raise RuntimeError("Unable to fullfil request") from e
return "hello world" | null |
5,222 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
ENDPOINT = "http://httpbin.org/status/500"
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
try:
ret = requests.get(ENDPOINT)
ret.raise_for_status()
except requests.HTTPError as e:
logger.exception("Received a HTTP 5xx error")
raise RuntimeError("Unable to fullfil request") from e
return "hello world" | null |
5,223 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.data_classes import APIGatewayProxyEvent
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
request = APIGatewayProxyEvent(event)
logger.set_correlation_id(request.request_context.request_id)
logger.info("Collecting payment")
return "hello world" | null |
5,224 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
order_id = event.get("order_id")
# this will ensure order_id key always has the latest value before logging
# alternative, you can use `clear_state=True` parameter in @inject_lambda_context
logger.append_keys(order_id=order_id)
logger.info("Collecting payment")
return "hello world" | null |
5,225 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
logger.append_keys(sample_key="value")
logger.info("Collecting payment")
logger.remove_keys(["sample_key"])
logger.info("Collecting payment without sample key")
return "hello world" | null |
5,226 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
def lambda_handler(event: dict, context: LambdaContext) -> str:
return "hello world" | null |
5,227 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
logger.info("Collecting payment")
# You can log entire objects too
logger.info({"operation": "collect_payment", "charge_id": event["charge_id"]})
return "hello world" | null |
5,228 | from dataclasses import dataclass
import fake_lambda_context_for_logger_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:809313241:function:test"
aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72"
return LambdaContext() | null |
5,229 | from dataclasses import dataclass
import fake_lambda_context_for_logger_module
import pytest
def test_lambda_handler(lambda_context):
test_event = {"test": "event"}
fake_lambda_context_for_logger_module.handler(test_event, lambda_context) | null |
5,230 | import requests
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
ENDPOINT = "http://httpbin.org/status/500"
def lambda_handler(event: dict, context: LambdaContext) -> str:
ret = requests.get(ENDPOINT)
# HTTP 4xx/5xx status will lead to requests.HTTPError
# Logger will log this exception before this program exits non-successfully
ret.raise_for_status()
return "hello world" | null |
5,231 | import json
import logging
from typing import Iterable, List, Optional
from aws_lambda_powertools import Logger
from aws_lambda_powertools.logging.formatter import BasePowertoolsFormatter
logger = Logger(service="payment", logger_formatter=CustomFormatter())
def lambda_handler(event, context):
logger.info("Collecting payment") | null |
5,232 | from typing import Dict, List
import boto3
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
client = boto3.client("s3")
def lambda_handler(event: Dict, context: LambdaContext) -> List:
response = client.list_buckets()
return response.get("Buckets", []) | null |
5,233 | import os
import requests
from aws_lambda_powertools import Logger
ENDPOINT = os.getenv("PAYMENT_API", "")
logger = Logger(service="payment")
class PaymentError(Exception):
...
def lambda_handler(event, context):
logger.append_keys(payment_id="123456789")
charge_id = event.get("charge_id", "")
try:
ret = requests.post(url=f"{ENDPOINT}/collect", data={"charge_id": charge_id})
ret.raise_for_status()
logger.info("Charge collected successfully", extra={"charge_id": charge_id})
return ret.json()
except requests.HTTPError as e:
raise PaymentError(f"Unable to collect payment for charge {charge_id}") from e
logger.info("goodbye") | null |
5,234 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
logger.debug(f"Correlation ID => {logger.get_correlation_id()}")
logger.info("Collecting payment")
return "hello world" | null |
5,235 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
logger.info("Collecting payment")
return "hello world" | null |
5,236 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
logger.info("Collecting payment", request_id="1123")
return "hello world" | null |
5,237 | from logging_inheritance_module import inject_payment_id
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
def inject_payment_id(context):
logger.append_keys(payment_id=context.get("payment_id"))
def lambda_handler(event: dict, context: LambdaContext) -> str:
inject_payment_id(context=event)
return "hello world" | null |
5,239 | from datetime import date, datetime
from aws_lambda_powertools import Logger
def custom_json_default(value: object) -> str:
if isinstance(value, (datetime, date)):
return value.isoformat()
return f"<non-serializable: {type(value).__name__}>" | null |
5,240 | from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
def lambda_handler(event: dict, context: LambdaContext) -> str:
if event.get("special_key"):
# Should only be available in the first request log
# as the second request doesn't contain `special_key`
logger.append_keys(debugging_key="value")
logger.info("Collecting payment")
return "hello world" | null |
5,241 | from typing import List
import requests
from pydantic import BaseModel, EmailStr, Field
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
from aws_lambda_powertools.utilities.typing import LambdaContext
def swagger_middleware(app: APIGatewayRestResolver, next_middleware: NextMiddleware) -> Response:
is_authenticated = ...
if not is_authenticated:
return Response(status_code=400, body="Unauthorized")
return next_middleware(app) | null |
5,242 | from typing import List
import requests
from pydantic import BaseModel, EmailStr, Field
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
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_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,243 | from typing import List
import requests
from pydantic import BaseModel, EmailStr, Field
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import NextMiddleware
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(enable_validation=True)
app.enable_swagger(middlewares=[swagger_middleware])
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,244 | 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()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,245 | 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 lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,246 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import VPCLatticeV2Resolver
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,247 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import VPCLatticeV2Resolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = VPCLatticeV2Resolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,248 | import requests
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import (
APIGatewayRestResolver,
Response,
content_types,
)
from aws_lambda_powertools.event_handler.exceptions import NotFoundError
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
app = APIGatewayRestResolver()
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 handle_not_found_errors(exc: NotFoundError) -> Response:
logger.info(f"Not found route: {app.current_event.path}")
return Response(status_code=418, content_type=content_types.TEXT_PLAIN, body="I'm a teapot!") | null |
5,249 | import requests
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import (
APIGatewayRestResolver,
Response,
content_types,
)
from aws_lambda_powertools.event_handler.exceptions import NotFoundError
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 {"todos": todos.json()[:10]} | null |
5,250 | import requests
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import (
APIGatewayRestResolver,
Response,
content_types,
)
from aws_lambda_powertools.event_handler.exceptions import NotFoundError
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,251 | 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 catch_any_route_get_method():
return {"path_received": app.current_event.path} | null |
5,252 | 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 lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,253 | 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, Response, content_types
from aws_lambda_powertools.event_handler.openapi.exceptions import RequestValidationError
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
logger = Logger()
app = APIGatewayRestResolver(enable_validation=True)
class RequestValidationError(ValidationException):
"""
Raised when the request body does not match the OpenAPI schema
"""
def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:
super().__init__(errors)
self.body = body
def handle_validation_error(ex: RequestValidationError):
logger.error("Request failed validation", path=app.current_event.path, errors=ex.errors())
return Response(
status_code=422,
content_type=content_types.APPLICATION_JSON,
body="Invalid data",
) | null |
5,254 | 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, Response, content_types
from aws_lambda_powertools.event_handler.openapi.exceptions import RequestValidationError
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 create_todo(todo: Todo) -> int:
response = requests.post("https://jsonplaceholder.typicode.com/todos", json=todo.dict(by_alias=True))
response.raise_for_status()
return response.json()["id"] | null |
5,255 | 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, Response, content_types
from aws_lambda_powertools.event_handler.openapi.exceptions import RequestValidationError
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,256 | from dataclasses import dataclass
import assert_alb_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,257 | from dataclasses import dataclass
import assert_alb_api_response_module
import pytest
def test_lambda_handler(lambda_context):
minimal_event = {
"path": "/todos",
"httpMethod": "GET",
"headers": {"x-amzn-trace-id": "b25827e5-0e30-4d52-85a8-4df449ee4c5a"},
}
# Example of Application Load Balancer request event:
# https://docs.aws.amazon.com/lambda/latest/dg/services-alb.html
ret = assert_alb_api_response_module.lambda_handler(minimal_event, lambda_context)
assert ret["statusCode"] == 200
assert ret["body"] != "" | null |
5,258 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayHttpResolver
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,259 | from typing import List, Optional
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():
todo_id: str = app.current_event.get_query_string_value(name="id", default_value="")
# alternatively
_: Optional[str] = app.current_event.query_string_parameters.get("id")
# or multi-value query string parameters; ?category="red"&?category="blue"
_: List[str] = app.current_event.get_multi_value_query_string_values(name="category")
# Payload
_: Optional[str] = app.current_event.body # raw str | None
endpoint = "https://jsonplaceholder.typicode.com/todos"
if todo_id:
endpoint = f"{endpoint}/{todo_id}"
todos: Response = requests.get(endpoint)
todos.raise_for_status()
return {"todos": todos.json()} | null |
5,260 | from typing import List, Optional
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 lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,261 | import os
from pathlib import Path
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler.api_gateway import (
APIGatewayRestResolver,
Response,
)
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
logo_file: bytes = Path(f"{os.getenv('LAMBDA_TASK_ROOT')}/logo.svg").read_bytes()
class Response(Generic[ResponseT]):
def __init__(
self,
status_code: int,
content_type: Optional[str] = None,
body: Optional[ResponseT] = None,
headers: Optional[Mapping[str, Union[str, List[str]]]] = None,
cookies: Optional[List[Cookie]] = None,
compress: Optional[bool] = None,
):
def is_json(self) -> bool:
def get_logo():
return Response(status_code=200, content_type="image/svg+xml", body=logo_file) | null |
5,262 | import os
from pathlib import Path
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler.api_gateway import (
APIGatewayRestResolver,
Response,
)
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,263 | 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 create_todo():
todo_data: dict = app.current_event.json_body # deserialize json str to dict
todo: Response = requests.post("https://jsonplaceholder.typicode.com/todos", data=todo_data)
todo.raise_for_status()
return {"todo": todo.json()} | null |
5,265 | 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)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,266 | from dataclasses import dataclass
import assert_function_url_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,267 | from dataclasses import dataclass
import assert_function_url_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 Lambda Function URL request event:
# https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html#urls-payloads
ret = assert_function_url_api_response_module.lambda_handler(minimal_event, lambda_context)
assert ret["statusCode"] == 200
assert ret["body"] != "" | null |
5,268 | from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.router import APIGatewayRouter
router = APIGatewayRouter()
def get_self():
# router.current_event is a APIGatewayProxyEvent
account_id = router.current_event.request_context.account_id
return {"account_id": account_id} | null |
5,269 | from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.event_handler.router import APIGatewayRouter
app = APIGatewayRestResolver()
app.include_router(router)
def lambda_handler(event, context):
return app.resolve(event, context) | null |
5,270 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, CORSConfig
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,271 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, CORSConfig
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,272 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, CORSConfig
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
def am_i_alive():
return {"am_i_alive": "yes"} | null |
5,273 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayRestResolver, CORSConfig
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayRestResolver(cors=cors_config)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,274 | from http import HTTPStatus
from uuid import uuid4
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.shared.cookies import Cookie
from aws_lambda_powertools.utilities.typing import LambdaContext
class Cookie:
"""
A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an
HTTP response or the Cookie header of an HTTP request.
See https://tools.ietf.org/html/rfc6265 for details.
"""
def __init__(
self,
name: str,
value: str,
path: str = "",
domain: str = "",
secure: bool = True,
http_only: bool = False,
max_age: Optional[int] = None,
expires: Optional[datetime] = None,
same_site: Optional[SameSite] = None,
custom_attributes: Optional[List[str]] = None,
):
"""
Parameters
----------
name: str
The name of this cookie, for example session_id
value: str
The cookie value, for instance an uuid
path: str
The path for which this cookie is valid. Optional
domain: str
The domain for which this cookie is valid. Optional
secure: bool
Marks the cookie as secure, only sendable to the server with an encrypted request over the HTTPS protocol
http_only: bool
Enabling this attribute makes the cookie inaccessible to the JavaScript `Document.cookie` API
max_age: Optional[int]
Defines the period of time after which the cookie is invalid. Use negative values to force cookie deletion.
expires: Optional[datetime]
Defines a date where the permanent cookie expires.
same_site: Optional[SameSite]
Determines if the cookie should be sent to third party websites
custom_attributes: Optional[List[str]]
List of additional custom attributes to set on the cookie
"""
self.name = name
self.value = value
self.path = path
self.domain = domain
self.secure = secure
self.expires = expires
self.max_age = max_age
self.http_only = http_only
self.same_site = same_site
self.custom_attributes = custom_attributes
def __str__(self) -> str:
payload = StringIO()
payload.write(f"{self.name}={self.value}")
if self.path:
payload.write(f"; Path={self.path}")
if self.domain:
payload.write(f"; Domain={self.domain}")
if self.expires:
payload.write(f"; Expires={_format_date(self.expires)}")
if self.max_age:
if self.max_age > 0:
payload.write(f"; MaxAge={self.max_age}")
else:
# negative or zero max-age should be set to 0
payload.write("; MaxAge=0")
if self.http_only:
payload.write("; HttpOnly")
if self.secure:
payload.write("; Secure")
if self.same_site:
payload.write(f"; SameSite={self.same_site.value}")
if self.custom_attributes:
for attr in self.custom_attributes:
payload.write(f"; {attr}")
return payload.getvalue()
def get_todos():
todos: requests.Response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos.raise_for_status()
custom_headers = {"X-Transaction-Id": [f"{uuid4()}"]}
return Response(
status_code=HTTPStatus.OK.value, # 200
content_type=content_types.APPLICATION_JSON,
body=todos.json()[:10],
headers=custom_headers,
cookies=[Cookie(name="session_id", value="12345")],
) | null |
5,275 | from http import HTTPStatus
from uuid import uuid4
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.shared.cookies import Cookie
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,276 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayHttpResolver
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,277 | import requests
from requests import Response
from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler import APIGatewayHttpResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
app = APIGatewayHttpResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,278 | 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 {"todos": todos.json()[:10]} | null |
5,279 | 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_todo_by_id(todo_id: str): # same example using Response class
todos: requests.Response = requests.get(f"https://jsonplaceholder.typicode.com/todos/{todo_id}")
todos.raise_for_status()
return Response(status_code=200, content_type=content_types.APPLICATION_JSON, body=todos.json()) | null |
5,280 | 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
app = APIGatewayRestResolver()
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context) | null |
5,281 | 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")
todos.raise_for_status()
# for brevity, we'll limit to the first 10 only
return {"todos": todos.json()[:10]} | null |
5,282 | 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])
def lambda_handler(event, context):
return app.resolve(event, context) | null |
5,283 | 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
logger = Logger()
app = APIGatewayRestResolver()
def handle_invalid_limit_qs(ex: ValueError): # receives exception raised
metadata = {"path": app.current_event.path, "query_strings": app.current_event.query_string_parameters}
logger.error(f"Malformed request: {ex}", extra=metadata)
return Response(
status_code=400,
content_type=content_types.TEXT_PLAIN,
body="Invalid request parameters.",
) | null |
5,284 | 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
app = APIGatewayRestResolver()
def get_todos():
# educational purpose only: we should receive a `ValueError`
# if a query string value for `limit` cannot be coerced to int
max_results: int = int(app.current_event.get_query_string_value(name="limit", default_value=0))
todos: requests.Response = requests.get(f"https://jsonplaceholder.typicode.com/todos?limit={max_results}")
todos.raise_for_status()
return {"todos": todos.json()} | null |
5,286 | 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 Query
from aws_lambda_powertools.shared.types import Annotated
from aws_lambda_powertools.utilities.typing import LambdaContext
class ExampleEnum(Enum):
"""Example of an Enum class."""
ONE = "value_one"
TWO = "value_two"
THREE = "value_three"
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,
)
The provided code snippet includes necessary dependencies for implementing the `get` function. Write a Python function `def get( example_multi_value_param: Annotated[ List[ExampleEnum], # (1)! Query( description="This is multi value query parameter.", ), ], )` to solve the following problem:
Return validated multi-value param values.
Here is the function:
def get(
example_multi_value_param: Annotated[
List[ExampleEnum], # (1)!
Query(
description="This is multi value query parameter.",
),
],
):
"""Return validated multi-value param values."""
return example_multi_value_param | Return validated multi-value param values. |
5,287 | 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 Query
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.