Yasuke/moto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Admin: Fix remaining ruff and pylint error (#7512)

Browse Source
This commit is contained in:
Akira Noda 2024-03-24 02:52:48 +09:00 committed by GitHub
parent e3555bbe61
commit ee4c5ed2d3
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
52 changed files with 314 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/build.yml vendored
View File

@ -68,7 +68,7 @@ jobs:
run: | run: |
pip install -r requirements-dev.txt pip install -r requirements-dev.txt
- name: Lint - name: Lint
run: run: |
mkdir .mypy_cache mkdir .mypy_cache
make lint make lint

6
moto/acmpca/models.py
View File

@ -136,9 +136,9 @@ class CertificateAuthority(BaseModel):
"S3ObjectAcl", None "S3ObjectAcl", None
) )
if acl is None: if acl is None:
self.revocation_configuration["CrlConfiguration"][ self.revocation_configuration["CrlConfiguration"]["S3ObjectAcl"] = (
"S3ObjectAcl" "PUBLIC_READ"
] = "PUBLIC_READ" )
else: else:
if acl not in ["PUBLIC_READ", "BUCKET_OWNER_FULL_CONTROL"]: if acl not in ["PUBLIC_READ", "BUCKET_OWNER_FULL_CONTROL"]:
raise InvalidS3ObjectAclInCrlConfiguration(acl) raise InvalidS3ObjectAclInCrlConfiguration(acl)

116
moto/apigateway/responses.py
View File

@ -39,9 +39,9 @@ class APIGatewayResponse(BaseResponse):
).format(api_key_source=api_key_source), ).format(api_key_source=api_key_source),
) )
def __validate_endpoint_configuration( def __validate_endpoint_configuration( # type: ignore[return]
self, endpoint_configuration: Dict[str, str] self, endpoint_configuration: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
if endpoint_configuration and "types" in endpoint_configuration: if endpoint_configuration and "types" in endpoint_configuration:
invalid_types = list( invalid_types = list(
set(endpoint_configuration["types"]) - set(ENDPOINT_CONFIGURATION_TYPES) set(endpoint_configuration["types"]) - set(ENDPOINT_CONFIGURATION_TYPES)
@ -57,9 +57,9 @@ class APIGatewayResponse(BaseResponse):
).format(endpoint_type=invalid_types[0]), ).format(endpoint_type=invalid_types[0]),
) )
def restapis( def restapis( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -105,9 +105,9 @@ class APIGatewayResponse(BaseResponse):
return 200, {}, json.dumps(rest_api.to_dict()) return 200, {}, json.dumps(rest_api.to_dict())
def __validte_rest_patch_operations( def __validte_rest_patch_operations( # type: ignore[return]
self, patch_operations: List[Dict[str, str]] self, patch_operations: List[Dict[str, str]]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
for op in patch_operations: for op in patch_operations:
path = op["path"] path = op["path"]
if "apiKeySource" in path: if "apiKeySource" in path:
@ -142,9 +142,9 @@ class APIGatewayResponse(BaseResponse):
return 200, {}, json.dumps(rest_api.to_dict()) return 200, {}, json.dumps(rest_api.to_dict())
def resources( def resources( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
function_id = self.path.replace("/restapis/", "", 1).split("/")[0] function_id = self.path.replace("/restapis/", "", 1).split("/")[0]
@ -156,9 +156,9 @@ class APIGatewayResponse(BaseResponse):
json.dumps({"item": [resource.to_dict() for resource in resources]}), json.dumps({"item": [resource.to_dict() for resource in resources]}),
) )
def gateway_response( def gateway_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "PUT": if request.method == "PUT":
return self.put_gateway_response() return self.put_gateway_response()
@ -167,16 +167,16 @@ class APIGatewayResponse(BaseResponse):
elif request.method == "DELETE": elif request.method == "DELETE":
return self.delete_gateway_response() return self.delete_gateway_response()
def gateway_responses( def gateway_responses( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "GET": if request.method == "GET":
return self.get_gateway_responses() return self.get_gateway_responses()
def resource_individual( def resource_individual( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
function_id = self.path.replace("/restapis/", "", 1).split("/")[0] function_id = self.path.replace("/restapis/", "", 1).split("/")[0]
resource_id = self.path.split("/")[-1] resource_id = self.path.split("/")[-1]
@ -268,9 +268,9 @@ class APIGatewayResponse(BaseResponse):
return 204, {}, json.dumps(method_response.to_json()) # type: ignore[union-attr] return 204, {}, json.dumps(method_response.to_json()) # type: ignore[union-attr]
raise Exception(f'Unexpected HTTP method "{self.method}"') raise Exception(f'Unexpected HTTP method "{self.method}"')
def restapis_authorizers( def restapis_authorizers( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
restapi_id = url_path_parts[2] restapi_id = url_path_parts[2]
@ -320,9 +320,9 @@ class APIGatewayResponse(BaseResponse):
authorizers = self.backend.get_authorizers(restapi_id) authorizers = self.backend.get_authorizers(restapi_id)
return 200, {}, json.dumps({"item": [a.to_json() for a in authorizers]}) return 200, {}, json.dumps({"item": [a.to_json() for a in authorizers]})
def request_validators( def request_validators( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
restapi_id = url_path_parts[2] restapi_id = url_path_parts[2]
@ -342,9 +342,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 201, {}, json.dumps(validator.to_dict()) return 201, {}, json.dumps(validator.to_dict())
def request_validator_individual( def request_validator_individual( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
restapi_id = url_path_parts[2] restapi_id = url_path_parts[2]
@ -363,9 +363,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 200, {}, json.dumps(validator.to_dict()) return 200, {}, json.dumps(validator.to_dict())
def authorizers( def authorizers( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
restapi_id = url_path_parts[2] restapi_id = url_path_parts[2]
@ -384,9 +384,9 @@ class APIGatewayResponse(BaseResponse):
self.backend.delete_authorizer(restapi_id, authorizer_id) self.backend.delete_authorizer(restapi_id, authorizer_id)
return 202, {}, "{}" return 202, {}, "{}"
def restapis_stages( def restapis_stages( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
function_id = url_path_parts[2] function_id = url_path_parts[2]
@ -417,9 +417,9 @@ class APIGatewayResponse(BaseResponse):
stages = self.backend.get_stages(function_id) stages = self.backend.get_stages(function_id)
return 200, {}, json.dumps({"item": [s.to_json() for s in stages]}) return 200, {}, json.dumps({"item": [s.to_json() for s in stages]})
def restapis_stages_tags( def restapis_stages_tags( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
function_id = url_path_parts[4] function_id = url_path_parts[4]
@ -437,9 +437,9 @@ class APIGatewayResponse(BaseResponse):
stage.tags.pop(tag, None) # type: ignore[union-attr] stage.tags.pop(tag, None) # type: ignore[union-attr]
return 200, {}, json.dumps({"item": ""}) return 200, {}, json.dumps({"item": ""})
def stages( def stages( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
function_id = url_path_parts[2] function_id = url_path_parts[2]
@ -476,9 +476,9 @@ class APIGatewayResponse(BaseResponse):
} }
return 200, headers, json.dumps(body).encode("utf-8") return 200, headers, json.dumps(body).encode("utf-8")
def integrations( def integrations( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
function_id = url_path_parts[2] function_id = url_path_parts[2]
@ -534,9 +534,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 204, {}, json.dumps(integration_response.to_json()) return 204, {}, json.dumps(integration_response.to_json())
def integration_responses( def integration_responses( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
function_id = url_path_parts[2] function_id = url_path_parts[2]
@ -574,9 +574,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 204, {}, json.dumps(integration_response.to_json()) return 204, {}, json.dumps(integration_response.to_json())
def deployments( def deployments( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
function_id = self.path.replace("/restapis/", "", 1).split("/")[0] function_id = self.path.replace("/restapis/", "", 1).split("/")[0]
@ -592,9 +592,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 201, {}, json.dumps(deployment.to_json()) return 201, {}, json.dumps(deployment.to_json())
def individual_deployment( def individual_deployment( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
function_id = url_path_parts[2] function_id = url_path_parts[2]
@ -607,9 +607,9 @@ class APIGatewayResponse(BaseResponse):
deployment = self.backend.delete_deployment(function_id, deployment_id) deployment = self.backend.delete_deployment(function_id, deployment_id)
return 202, {}, json.dumps(deployment.to_json()) return 202, {}, json.dumps(deployment.to_json())
def apikeys( def apikeys( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -649,9 +649,9 @@ class APIGatewayResponse(BaseResponse):
return 200, {}, json.dumps(apikey_resp) return 200, {}, json.dumps(apikey_resp)
def usage_plans( def usage_plans( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
usage_plan_response = self.backend.create_usage_plan(json.loads(self.body)) usage_plan_response = self.backend.create_usage_plan(json.loads(self.body))
@ -665,9 +665,9 @@ class APIGatewayResponse(BaseResponse):
json.dumps({"item": [u.to_json() for u in usage_plans_response]}), json.dumps({"item": [u.to_json() for u in usage_plans_response]}),
) )
def usage_plan_individual( def usage_plan_individual( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
@ -686,9 +686,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 200, {}, json.dumps(usage_plan_response.to_json()) return 200, {}, json.dumps(usage_plan_response.to_json())
def usage_plan_keys( def usage_plan_keys( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
@ -707,9 +707,9 @@ class APIGatewayResponse(BaseResponse):
json.dumps({"item": [u.to_json() for u in usage_plans_response]}), json.dumps({"item": [u.to_json() for u in usage_plans_response]}),
) )
def usage_plan_key_individual( def usage_plan_key_individual( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
@ -723,9 +723,9 @@ class APIGatewayResponse(BaseResponse):
self.backend.delete_usage_plan_key(usage_plan_id, key_id) self.backend.delete_usage_plan_key(usage_plan_id, key_id)
return 202, {}, "{}" return 202, {}, "{}"
def domain_names( def domain_names( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -780,9 +780,9 @@ class APIGatewayResponse(BaseResponse):
msg = f'Method "{self.method}" for API GW domain names not implemented' msg = f'Method "{self.method}" for API GW domain names not implemented'
return 404, {}, json.dumps({"error": msg}) return 404, {}, json.dumps({"error": msg})
def models( def models( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
rest_api_id = self.path.replace("/restapis/", "", 1).split("/")[0] rest_api_id = self.path.replace("/restapis/", "", 1).split("/")[0]
@ -817,9 +817,9 @@ class APIGatewayResponse(BaseResponse):
return 200, {}, json.dumps(model_info.to_json()) return 200, {}, json.dumps(model_info.to_json())
return 200, {}, "{}" return 200, {}, "{}"
def base_path_mappings( def base_path_mappings( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
@ -842,9 +842,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 201, {}, json.dumps(base_path_mapping_resp.to_json()) return 201, {}, json.dumps(base_path_mapping_resp.to_json())
def base_path_mapping_individual( def base_path_mapping_individual( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
@ -866,9 +866,9 @@ class APIGatewayResponse(BaseResponse):
) )
return 200, {}, json.dumps(base_path_mapping.to_json()) return 200, {}, json.dumps(base_path_mapping.to_json())
def vpc_link( def vpc_link( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
url_path_parts = self.path.split("/") url_path_parts = self.path.split("/")
vpc_link_id = url_path_parts[-1] vpc_link_id = url_path_parts[-1]
@ -880,9 +880,9 @@ class APIGatewayResponse(BaseResponse):
vpc_link = self.backend.get_vpc_link(vpc_link_id=vpc_link_id) vpc_link = self.backend.get_vpc_link(vpc_link_id=vpc_link_id)
return 200, {}, json.dumps(vpc_link.to_json()) return 200, {}, json.dumps(vpc_link.to_json())
def vpc_links( def vpc_links( # type: ignore[return]
self, request: Any, full_url: str, headers: Dict[str, str] self, request: Any, full_url: str, headers: Dict[str, str]
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":

20
moto/apigatewayv2/responses.py
View File

@ -63,9 +63,9 @@ class ApiGatewayV2Response(BaseResponse):
if self.method == "DELETE": if self.method == "DELETE":
return self.delete_cors_configuration() return self.delete_cors_configuration()
def route_request_parameter( def route_request_parameter( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "DELETE": if self.method == "DELETE":
@ -105,9 +105,9 @@ class ApiGatewayV2Response(BaseResponse):
if self.method == "POST": if self.method == "POST":
return self.create_integration() return self.create_integration()
def integration_response( def integration_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "DELETE": if self.method == "DELETE":
@ -117,9 +117,9 @@ class ApiGatewayV2Response(BaseResponse):
if self.method == "PATCH": if self.method == "PATCH":
return self.update_integration_response() return self.update_integration_response()
def integration_responses( def integration_responses( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -145,9 +145,9 @@ class ApiGatewayV2Response(BaseResponse):
if self.method == "POST": if self.method == "POST":
return self.create_route() return self.create_route()
def route_response( def route_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "DELETE": if self.method == "DELETE":
@ -155,9 +155,9 @@ class ApiGatewayV2Response(BaseResponse):
if self.method == "GET": if self.method == "GET":
return self.get_route_response() return self.get_route_response()
def route_responses( def route_responses( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":

12
moto/appsync/responses.py
View File

@ -27,9 +27,9 @@ class AppSyncResponse(BaseResponse):
if request.method == "GET": if request.method == "GET":
return self.list_graphql_apis() return self.list_graphql_apis()
def graph_ql_individual( def graph_ql_individual( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "GET": if request.method == "GET":
return self.get_graphql_api() return self.get_graphql_api()
@ -45,18 +45,18 @@ class AppSyncResponse(BaseResponse):
if request.method == "GET": if request.method == "GET":
return self.list_api_keys() return self.list_api_keys()
def schemacreation( def schemacreation( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "POST": if request.method == "POST":
return self.start_schema_creation() return self.start_schema_creation()
if request.method == "GET": if request.method == "GET":
return self.get_schema_creation_status() return self.get_schema_creation_status()
def api_key_individual( def api_key_individual( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "DELETE": if request.method == "DELETE":
return self.delete_api_key() return self.delete_api_key()

20
moto/awslambda/responses.py
View File

@ -89,9 +89,9 @@ class LambdaResponse(BaseResponse):
if request.method == "GET": if request.method == "GET":
return self._list_layers() return self._list_layers()
def layers_version( def layers_version( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
layer_name = unquote(self.path.split("/")[-3]) layer_name = unquote(self.path.split("/")[-3])
layer_version = self.path.split("/")[-1] layer_version = self.path.split("/")[-1]
@ -100,9 +100,9 @@ class LambdaResponse(BaseResponse):
elif request.method == "GET": elif request.method == "GET":
return self._get_layer_version(layer_name, layer_version) return self._get_layer_version(layer_name, layer_version)
def layers_versions( def layers_versions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "GET": if request.method == "GET":
return self._get_layer_versions() return self._get_layer_versions()
@ -190,9 +190,9 @@ class LambdaResponse(BaseResponse):
else: else:
raise ValueError("Cannot handle request") raise ValueError("Cannot handle request")
def code_signing_config( def code_signing_config( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "GET": if request.method == "GET":
return self._get_code_signing_config() return self._get_code_signing_config()
@ -212,9 +212,9 @@ class LambdaResponse(BaseResponse):
else: else:
raise ValueError("Cannot handle request") raise ValueError("Cannot handle request")
def function_url_config( def function_url_config( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
http_method = request.method http_method = request.method
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
@ -417,9 +417,9 @@ class LambdaResponse(BaseResponse):
return 204, {}, "" return 204, {}, ""
@staticmethod @staticmethod
def _set_configuration_qualifier( def _set_configuration_qualifier( # type: ignore[misc]
configuration: Dict[str, Any], function_name: str, qualifier: str configuration: Dict[str, Any], function_name: str, qualifier: str
) -> Dict[str, Any]: # type: ignore[misc] ) -> Dict[str, Any]:
# Qualifier may be explicitly passed or part of function name or ARN, extract it here # Qualifier may be explicitly passed or part of function name or ARN, extract it here
if function_name.startswith("arn:aws"): if function_name.startswith("arn:aws"):
# Extract from ARN # Extract from ARN

8
moto/cloudformation/parsing.py
View File

@ -343,8 +343,8 @@ def parse_resource_and_generate_name(
generated_resource_name = generate_resource_name( generated_resource_name = generate_resource_name(
resource_type, resource_type,
resources_map["AWS::StackName"], resources_map["AWS::StackName"], # type: ignore[arg-type]
logical_id, # type: ignore[arg-type] logical_id,
) )
resource_name_property = resource_name_property_from_type(resource_type) resource_name_property = resource_name_property_from_type(resource_type)
@ -438,11 +438,11 @@ def parse_and_delete_resource(
) )
def parse_condition( def parse_condition( # type: ignore[return]
condition: Union[Dict[str, Any], bool], condition: Union[Dict[str, Any], bool],
resources_map: "ResourceMap", resources_map: "ResourceMap",
condition_map: Dict[str, Any], condition_map: Dict[str, Any],
) -> bool: # type: ignore[return] ) -> bool:
if isinstance(condition, bool): if isinstance(condition, bool):
return condition return condition

12
moto/cloudfront/responses.py
View File

@ -40,18 +40,18 @@ class CloudFrontResponse(BaseResponse):
if request.method == "GET": if request.method == "GET":
return self.list_tags_for_resource() return self.list_tags_for_resource()
def origin_access_controls( def origin_access_controls( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "POST": if request.method == "POST":
return self.create_origin_access_control() return self.create_origin_access_control()
if request.method == "GET": if request.method == "GET":
return self.list_origin_access_controls() return self.list_origin_access_controls()
def origin_access_control( def origin_access_control( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "GET": if request.method == "GET":
return self.get_origin_access_control() return self.get_origin_access_control()
@ -86,9 +86,9 @@ class CloudFrontResponse(BaseResponse):
response = template.render(distributions=distributions) response = template.render(distributions=distributions)
return 200, {}, response return 200, {}, response
def individual_distribution( def individual_distribution( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
distribution_id = full_url.split("/")[-1] distribution_id = full_url.split("/")[-1]
if request.method == "DELETE": if request.method == "DELETE":

2
moto/codecommit/models.py
View File

@ -1,4 +1,4 @@
from typing import Dict, List, Optional from typing import Dict, Optional
from moto.core.base_backend import BackendDict, BaseBackend from moto.core.base_backend import BackendDict, BaseBackend
from moto.core.common_models import BaseModel from moto.core.common_models import BaseModel

12
moto/databrew/responses.py
View File

@ -29,9 +29,9 @@ class DataBrewResponse(BaseResponse):
tags = self.parameters.get("Tags") tags = self.parameters.get("Tags")
return json.dumps( return json.dumps(
self.databrew_backend.create_recipe( self.databrew_backend.create_recipe(
recipe_name, recipe_name, # type: ignore[arg-type]
recipe_description, recipe_description, # type: ignore[arg-type]
recipe_steps, recipe_steps, # type: ignore[arg-type]
tags, # type: ignore[arg-type] tags, # type: ignore[arg-type]
).as_dict() ).as_dict()
) )
@ -102,7 +102,7 @@ class DataBrewResponse(BaseResponse):
self.databrew_backend.update_recipe( self.databrew_backend.update_recipe(
recipe_name, recipe_name,
recipe_description, recipe_description, # type: ignore[arg-type]
recipe_steps, # type: ignore[arg-type] recipe_steps, # type: ignore[arg-type]
) )
return json.dumps({"Name": recipe_name}) return json.dumps({"Name": recipe_name})
@ -147,8 +147,8 @@ class DataBrewResponse(BaseResponse):
ruleset = self.databrew_backend.update_ruleset( ruleset = self.databrew_backend.update_ruleset(
ruleset_name, ruleset_name,
ruleset_description, ruleset_description, # type: ignore[arg-type]
ruleset_rules, ruleset_rules, # type: ignore[arg-type]
tags, # type: ignore[arg-type] tags, # type: ignore[arg-type]
) )
return json.dumps(ruleset.as_dict()) return json.dumps(ruleset.as_dict())

2
moto/datasync/models.py
View File

@ -1,5 +1,5 @@
from collections import OrderedDict from collections import OrderedDict
from typing import Any, Dict, List, Optional from typing import Any, Dict, Optional
from moto.core.base_backend import BackendDict, BaseBackend from moto.core.base_backend import BackendDict, BaseBackend
from moto.core.common_models import BaseModel from moto.core.common_models import BaseModel

4
moto/dynamodb/models/__init__.py
View File

@ -478,8 +478,8 @@ class DynamoDBBackend(BaseBackend):
try: try:
UpdateExpressionExecutor( UpdateExpressionExecutor(
validated_ast, validated_ast,
item, item, # type: ignore[arg-type]
expression_attribute_names, # type: ignore[arg-type] expression_attribute_names,
).execute() ).execute()
except ItemSizeTooLarge: except ItemSizeTooLarge:
raise ItemSizeToUpdateTooLarge() raise ItemSizeToUpdateTooLarge()

8
moto/dynamodb/models/table.py
View File

@ -76,9 +76,9 @@ class LocalSecondaryIndex(SecondaryIndex):
} }
@staticmethod @staticmethod
def create( def create( # type: ignore[misc]
dct: Dict[str, Any], table_key_attrs: List[str] dct: Dict[str, Any], table_key_attrs: List[str]
) -> "LocalSecondaryIndex": # type: ignore[misc] ) -> "LocalSecondaryIndex":
return LocalSecondaryIndex( return LocalSecondaryIndex(
index_name=dct["IndexName"], index_name=dct["IndexName"],
schema=dct["KeySchema"], schema=dct["KeySchema"],
@ -114,9 +114,9 @@ class GlobalSecondaryIndex(SecondaryIndex):
} }
@staticmethod @staticmethod
def create( def create( # type: ignore[misc]
dct: Dict[str, Any], table_key_attrs: List[str] dct: Dict[str, Any], table_key_attrs: List[str]
) -> "GlobalSecondaryIndex": # type: ignore[misc] ) -> "GlobalSecondaryIndex":
return GlobalSecondaryIndex( return GlobalSecondaryIndex(
index_name=dct["IndexName"], index_name=dct["IndexName"],
schema=dct["KeySchema"], schema=dct["KeySchema"],

12
moto/dynamodb/parsing/validators.py
View File

@ -257,9 +257,9 @@ class UpdateExpressionFunctionEvaluator(DepthFirstTraverser): # type: ignore[mi
raise NotImplementedError(f"Unsupported function for moto {function_name}") raise NotImplementedError(f"Unsupported function for moto {function_name}")
@classmethod @classmethod
def get_list_from_ddb_typed_value( def get_list_from_ddb_typed_value( # type: ignore[misc]
cls, node: DDBTypedValue, function_name: str cls, node: DDBTypedValue, function_name: str
) -> DynamoType: # type: ignore[misc] ) -> DynamoType:
assert isinstance(node, DDBTypedValue) assert isinstance(node, DDBTypedValue)
dynamo_value = node.get_value() dynamo_value = node.get_value()
assert isinstance(dynamo_value, DynamoType) assert isinstance(dynamo_value, DynamoType)
@ -324,9 +324,9 @@ class ExecuteOperations(DepthFirstTraverser): # type: ignore[misc]
return dynamo_value return dynamo_value
@classmethod @classmethod
def get_sum( def get_sum( # type: ignore[misc]
cls, left_operand: DynamoType, right_operand: DynamoType cls, left_operand: DynamoType, right_operand: DynamoType
) -> DDBTypedValue: # type: ignore[misc] ) -> DDBTypedValue:
""" """
Args: Args:
left_operand(DynamoType): left_operand(DynamoType):
@ -341,9 +341,9 @@ class ExecuteOperations(DepthFirstTraverser): # type: ignore[misc]
raise IncorrectOperandType("+", left_operand.type) raise IncorrectOperandType("+", left_operand.type)
@classmethod @classmethod
def get_subtraction( def get_subtraction( # type: ignore[misc]
cls, left_operand: DynamoType, right_operand: DynamoType cls, left_operand: DynamoType, right_operand: DynamoType
) -> DDBTypedValue: # type: ignore[misc] ) -> DDBTypedValue:
""" """
Args: Args:
left_operand(DynamoType): left_operand(DynamoType):

4
moto/dynamodb_v20111205/models.py
View File

@ -166,8 +166,8 @@ class Table(BaseModel):
hash_value = DynamoType(item_attrs.get(self.hash_key_attr)) # type: ignore[arg-type] hash_value = DynamoType(item_attrs.get(self.hash_key_attr)) # type: ignore[arg-type]
if self.has_range_key: if self.has_range_key:
range_value: Optional[DynamoType] = DynamoType( range_value: Optional[DynamoType] = DynamoType(
item_attrs.get(self.range_key_attr) item_attrs.get(self.range_key_attr) # type: ignore[arg-type]
) # type: ignore[arg-type] )
else: else:
range_value = None range_value = None

2
moto/dynamodbstreams/models.py
View File

@ -129,7 +129,7 @@ class DynamoDBStreamsBackend(BaseBackend):
shard_iterator = ShardIterator( shard_iterator = ShardIterator(
self, self,
table.stream_shard, table.stream_shard, # type: ignore[arg-type]
shard_iterator_type, shard_iterator_type,
sequence_number, # type: ignore[arg-type] sequence_number, # type: ignore[arg-type]
) )

8
moto/ebs/responses.py
View File

@ -25,18 +25,18 @@ class EBSResponse(BaseResponse):
if request.method == "POST": if request.method == "POST":
return self.start_snapshot() return self.start_snapshot()
def snapshot_block( def snapshot_block( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers, use_raw_body=True) self.setup_class(request, full_url, headers, use_raw_body=True)
if request.method == "PUT": if request.method == "PUT":
return self.put_snapshot_block(full_url, headers) return self.put_snapshot_block(full_url, headers)
if request.method == "GET": if request.method == "GET":
return self.get_snapshot_block() return self.get_snapshot_block()
def snapshot_blocks( def snapshot_blocks( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "GET": if request.method == "GET":
return self.list_snapshot_blocks() return self.list_snapshot_blocks()

2
moto/ec2/models/__init__.py
View File

@ -1,4 +1,4 @@
from typing import Any, Dict, List from typing import List
from moto.core.base_backend import BackendDict, BaseBackend from moto.core.base_backend import BackendDict, BaseBackend

8
moto/ec2/models/iam_instance_profile.py
View File

@ -50,9 +50,9 @@ class IamInstanceProfileAssociationBackend:
iam_association_id = random_iam_instance_profile_association_id() iam_association_id = random_iam_instance_profile_association_id()
instance_profile = filter_iam_instance_profiles( instance_profile = filter_iam_instance_profiles(
self.account_id, self.account_id, # type: ignore[attr-defined]
iam_instance_profile_arn, iam_instance_profile_arn,
iam_instance_profile_name, # type: ignore[attr-defined] iam_instance_profile_name,
) )
if instance_id in self.iam_instance_profile_associations.keys(): if instance_id in self.iam_instance_profile_associations.keys():
@ -127,9 +127,9 @@ class IamInstanceProfileAssociationBackend:
iam_instance_profile_arn: Optional[str] = None, iam_instance_profile_arn: Optional[str] = None,
) -> IamInstanceProfileAssociation: ) -> IamInstanceProfileAssociation:
instance_profile = filter_iam_instance_profiles( instance_profile = filter_iam_instance_profiles(
self.account_id, self.account_id, # type: ignore[attr-defined]
iam_instance_profile_arn, iam_instance_profile_arn,
iam_instance_profile_name, # type: ignore[attr-defined] iam_instance_profile_name,
) )
iam_instance_profile_association = None iam_instance_profile_association = None

4
moto/ec2/models/instances.py
View File

@ -668,8 +668,8 @@ class InstanceBackend:
raise InvalidInstanceTypeError(kwargs["instance_type"]) raise InvalidInstanceTypeError(kwargs["instance_type"])
security_groups = [ security_groups = [
self.get_security_group_by_name_or_id(name) self.get_security_group_by_name_or_id(name) # type: ignore[attr-defined]
for name in security_group_names # type: ignore[attr-defined] for name in security_group_names
] ]
for sg_id in kwargs.pop("security_group_ids", []): for sg_id in kwargs.pop("security_group_ids", []):

4
moto/ec2/models/route_tables.py
View File

@ -489,8 +489,8 @@ class RouteBackend:
route.instance = self.get_instance(instance_id) if instance_id else None # type: ignore[attr-defined] route.instance = self.get_instance(instance_id) if instance_id else None # type: ignore[attr-defined]
route.interface = ( route.interface = (
self.get_network_interface(interface_id) if interface_id else None self.get_network_interface(interface_id) if interface_id else None # type: ignore[attr-defined]
) # type: ignore[attr-defined] )
route.vpc_pcx = ( route.vpc_pcx = (
self.get_vpc_peering_connection(vpc_peering_connection_id) # type: ignore[attr-defined] self.get_vpc_peering_connection(vpc_peering_connection_id) # type: ignore[attr-defined]
if vpc_peering_connection_id if vpc_peering_connection_id

4
moto/ec2/models/security_groups.py
View File

@ -629,9 +629,9 @@ class SecurityGroupBackend:
return results return results
@staticmethod @staticmethod
def _match_sg_rules( def _match_sg_rules( # type: ignore[misc]
rules_list: List[SecurityRule], filters: Any rules_list: List[SecurityRule], filters: Any
) -> List[SecurityRule]: # type: ignore[misc] ) -> List[SecurityRule]:
results = [] results = []
for rule in rules_list: for rule in rules_list:
if rule.match_tags(filters): if rule.match_tags(filters):

20
moto/ec2/models/transit_gateway_attachments.py
View File

@ -235,8 +235,8 @@ class TransitGatewayAttachmentBackend:
if remove_subnet_ids: if remove_subnet_ids:
tgw_attachment.subnet_ids = [ # type: ignore[attr-defined] tgw_attachment.subnet_ids = [ # type: ignore[attr-defined]
id id
for id in tgw_attachment.subnet_ids for id in tgw_attachment.subnet_ids # type: ignore[attr-defined]
if id not in remove_subnet_ids # type: ignore[attr-defined] if id not in remove_subnet_ids
] ]
if options: if options:
@ -359,16 +359,16 @@ class TransitGatewayAttachmentBackend:
# For cross-account peering, must be accepted by the accepter # For cross-account peering, must be accepted by the accepter
if ( if (
requester_account_id != accepter_account_id requester_account_id != accepter_account_id
and self.account_id != accepter_account_id and self.account_id != accepter_account_id # type: ignore[attr-defined]
): # type: ignore[attr-defined] ):
raise InvalidParameterValueErrorPeeringAttachment( raise InvalidParameterValueErrorPeeringAttachment(
"accept", transit_gateway_attachment_id "accept", transit_gateway_attachment_id
) )
if ( if (
requester_region_name != accepter_region_name requester_region_name != accepter_region_name
and self.region_name != accepter_region_name and self.region_name != accepter_region_name # type: ignore[attr-defined]
): # type: ignore[attr-defined] ):
raise InvalidParameterValueErrorPeeringAttachment( raise InvalidParameterValueErrorPeeringAttachment(
"accept", transit_gateway_attachment_id "accept", transit_gateway_attachment_id
) )
@ -393,16 +393,16 @@ class TransitGatewayAttachmentBackend:
if ( if (
requester_account_id != accepter_account_id requester_account_id != accepter_account_id
and self.account_id != accepter_account_id and self.account_id != accepter_account_id # type: ignore[attr-defined]
): # type: ignore[attr-defined] ):
raise InvalidParameterValueErrorPeeringAttachment( raise InvalidParameterValueErrorPeeringAttachment(
"reject", transit_gateway_attachment_id "reject", transit_gateway_attachment_id
) )
if ( if (
requester_region_name != accepter_region_name requester_region_name != accepter_region_name
and self.region_name != accepter_region_name and self.region_name != accepter_region_name # type: ignore[attr-defined]
): # type: ignore[attr-defined] ):
raise InvalidParameterValueErrorPeeringAttachment( raise InvalidParameterValueErrorPeeringAttachment(
"reject", transit_gateway_attachment_id "reject", transit_gateway_attachment_id
) )

16
moto/ec2/models/vpcs.py
View File

@ -1044,15 +1044,17 @@ class VPCBackend:
# Return sensible defaults, for services that do not offer a custom implementation # Return sensible defaults, for services that do not offer a custom implementation
for aws_service in AWS_ENDPOINT_SERVICES: for aws_service in AWS_ENDPOINT_SERVICES:
if aws_service not in COVERED_ENDPOINT_SERVICES: if aws_service not in COVERED_ENDPOINT_SERVICES:
service_configs = BaseBackend.default_vpc_endpoint_service_factory(region, zones, aws_service) service_configs = BaseBackend.default_vpc_endpoint_service_factory(
region, zones, aws_service
)
DEFAULT_VPC_ENDPOINT_SERVICES[region].extend(service_configs) DEFAULT_VPC_ENDPOINT_SERVICES[region].extend(service_configs)
return DEFAULT_VPC_ENDPOINT_SERVICES[region] return DEFAULT_VPC_ENDPOINT_SERVICES[region]
@staticmethod @staticmethod
def _matches_service_by_tags( def _matches_service_by_tags( # type: ignore[misc]
service: Dict[str, Any], filter_item: Dict[str, Any] service: Dict[str, Any], filter_item: Dict[str, Any]
) -> bool: # type: ignore[misc] ) -> bool:
"""Return True if service tags are not filtered by their tags. """Return True if service tags are not filtered by their tags.
Note that the API specifies a key of "Values" for a filter, but Note that the API specifies a key of "Values" for a filter, but
@ -1084,11 +1086,11 @@ class VPCBackend:
return matched return matched
@staticmethod @staticmethod
def _filter_endpoint_services( def _filter_endpoint_services( # type: ignore[misc]
service_names_filters: List[str], service_names_filters: List[str],
filters: List[Dict[str, Any]], filters: List[Dict[str, Any]],
services: List[Dict[str, Any]], services: List[Dict[str, Any]],
) -> List[Dict[str, Any]]: # type: ignore[misc] ) -> List[Dict[str, Any]]:
"""Return filtered list of VPC endpoint services.""" """Return filtered list of VPC endpoint services."""
if not service_names_filters and not filters: if not service_names_filters and not filters:
return services return services
@ -1161,8 +1163,8 @@ class VPCBackend:
The DryRun parameter is ignored. The DryRun parameter is ignored.
""" """
default_services = self._collect_default_endpoint_services( default_services = self._collect_default_endpoint_services(
self.account_id, self.account_id, # type: ignore[attr-defined]
region, # type: ignore[attr-defined] region,
) )
custom_services = [x.to_dict() for x in self.configurations.values()] # type: ignore custom_services = [x.to_dict() for x in self.configurations.values()] # type: ignore
all_services = default_services + custom_services all_services = default_services + custom_services

4
moto/ecr/models.py
View File

@ -403,9 +403,9 @@ class ECRBackend(BaseBackend):
self.tagger = TaggingService(tag_name="tags") self.tagger = TaggingService(tag_name="tags")
@staticmethod @staticmethod
def default_vpc_endpoint_service( def default_vpc_endpoint_service( # type: ignore[misc]
service_region: str, zones: List[str] service_region: str, zones: List[str]
) -> List[Dict[str, Any]]: # type: ignore[misc] ) -> List[Dict[str, Any]]:
"""Default VPC endpoint service.""" """Default VPC endpoint service."""
docker_endpoint = { docker_endpoint = {
"AcceptanceRequired": False, "AcceptanceRequired": False,

12
moto/ecs/models.py
View File

@ -1207,11 +1207,11 @@ class EC2ContainerServiceBackend(BaseBackend):
return task_definition return task_definition
@staticmethod @staticmethod
def _validate_container_defs( def _validate_container_defs( # type: ignore[misc]
memory: Optional[str], memory: Optional[str],
container_definitions: List[Dict[str, Any]], container_definitions: List[Dict[str, Any]],
requires_compatibilities: Optional[List[str]], requires_compatibilities: Optional[List[str]],
) -> None: # type: ignore[misc] ) -> None:
# The capitalised keys are passed by Cloudformation # The capitalised keys are passed by Cloudformation
for cd in container_definitions: for cd in container_definitions:
if "name" not in cd and "Name" not in cd: if "name" not in cd and "Name" not in cd:
@ -1356,9 +1356,9 @@ class EC2ContainerServiceBackend(BaseBackend):
return tasks return tasks
@staticmethod @staticmethod
def _calculate_task_resource_requirements( def _calculate_task_resource_requirements( # type: ignore[misc]
task_definition: TaskDefinition, task_definition: TaskDefinition,
) -> Dict[str, Any]: # type: ignore[misc] ) -> Dict[str, Any]:
resource_requirements: Dict[str, Any] = { resource_requirements: Dict[str, Any] = {
"CPU": 0, "CPU": 0,
"MEMORY": 0, "MEMORY": 0,
@ -1400,10 +1400,10 @@ class EC2ContainerServiceBackend(BaseBackend):
return resource_requirements return resource_requirements
@staticmethod @staticmethod
def _can_be_placed( def _can_be_placed( # type: ignore[misc]
container_instance: ContainerInstance, container_instance: ContainerInstance,
task_resource_requirements: Dict[str, Any], task_resource_requirements: Dict[str, Any],
) -> bool: # type: ignore[misc] ) -> bool:
""" """
:param container_instance: The container instance trying to be placed onto :param container_instance: The container instance trying to be placed onto

4
moto/elb/responses.py
View File

@ -405,7 +405,7 @@ class ELBResponse(BaseResponse):
subnets = params.get("Subnets") subnets = params.get("Subnets")
all_subnets = self.elb_backend.attach_load_balancer_to_subnets( all_subnets = self.elb_backend.attach_load_balancer_to_subnets(
load_balancer_name, load_balancer_name, # type: ignore[arg-type]
subnets, # type: ignore[arg-type] subnets, # type: ignore[arg-type]
) )
template = self.response_template(ATTACH_LB_TO_SUBNETS_TEMPLATE) template = self.response_template(ATTACH_LB_TO_SUBNETS_TEMPLATE)
@ -417,7 +417,7 @@ class ELBResponse(BaseResponse):
subnets = params.get("Subnets") subnets = params.get("Subnets")
all_subnets = self.elb_backend.detach_load_balancer_from_subnets( all_subnets = self.elb_backend.detach_load_balancer_from_subnets(
load_balancer_name, load_balancer_name, # type: ignore[arg-type]
subnets, # type: ignore[arg-type] subnets, # type: ignore[arg-type]
) )
template = self.response_template(DETACH_LB_FROM_SUBNETS_TEMPLATE) template = self.response_template(DETACH_LB_FROM_SUBNETS_TEMPLATE)

4
moto/emr/utils.py
View File

@ -455,9 +455,9 @@ class EmrSecurityGroupManager:
pass pass
@staticmethod @staticmethod
def _render_rules( def _render_rules( # type: ignore[misc]
rules: Any, managed_groups: Dict[str, Any] rules: Any, managed_groups: Dict[str, Any]
) -> List[Dict[str, Any]]: # type: ignore[misc] ) -> List[Dict[str, Any]]:
rendered_rules = copy.deepcopy(rules) rendered_rules = copy.deepcopy(rules)
for rule in rendered_rules: for rule in rendered_rules:
rule["group_name_or_id"] = managed_groups[rule["group_name_or_id"]].id rule["group_name_or_id"] = managed_groups[rule["group_name_or_id"]].id

4
moto/events/models.py
View File

@ -1389,9 +1389,9 @@ class EventsBackend(BaseBackend):
) )
@staticmethod @staticmethod
def _condition_param_to_stmt_condition( def _condition_param_to_stmt_condition( # type: ignore[misc]
condition: Optional[Dict[str, Any]], condition: Optional[Dict[str, Any]],
) -> Optional[Dict[str, Any]]: # type: ignore[misc] ) -> Optional[Dict[str, Any]]:
if condition: if condition:
key = condition["Key"] key = condition["Key"]
value = condition["Value"] value = condition["Value"]

4
moto/firehose/models.py
View File

@ -413,9 +413,9 @@ class FirehoseBackend(BaseBackend):
} }
@staticmethod @staticmethod
def put_http_records( def put_http_records( # type: ignore[misc]
http_destination: Dict[str, Any], records: List[Dict[str, bytes]] http_destination: Dict[str, Any], records: List[Dict[str, bytes]]
) -> List[Dict[str, str]]: # type: ignore[misc] ) -> List[Dict[str, str]]:
"""Put records to a HTTP destination.""" """Put records to a HTTP destination."""
# Mostly copied from localstack # Mostly copied from localstack
url = http_destination["EndpointConfiguration"]["Url"] url = http_destination["EndpointConfiguration"]["Url"]

12
moto/glacier/responses.py
View File

@ -37,9 +37,9 @@ class GlacierResponse(BaseResponse):
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
return self._vault_response(request, full_url, headers) return self._vault_response(request, full_url, headers)
def _vault_response( def _vault_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
method = request.method method = request.method
vault_name = vault_from_glacier_url(full_url) vault_name = vault_from_glacier_url(full_url)
@ -103,9 +103,9 @@ class GlacierResponse(BaseResponse):
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
return self._vault_archive_individual_response(request, full_url, headers) return self._vault_archive_individual_response(request, full_url, headers)
def _vault_archive_individual_response( def _vault_archive_individual_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
method = request.method method = request.method
vault_name = full_url.split("/")[-3] vault_name = full_url.split("/")[-3]
archive_id = full_url.split("/")[-1] archive_id = full_url.split("/")[-1]
@ -121,9 +121,9 @@ class GlacierResponse(BaseResponse):
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
return self._vault_jobs_response(request, full_url, headers) return self._vault_jobs_response(request, full_url, headers)
def _vault_jobs_response( def _vault_jobs_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
method = request.method method = request.method
if hasattr(request, "body"): if hasattr(request, "body"):
body = request.body body = request.body

32
moto/glue/responses.py
View File

@ -32,8 +32,10 @@ class GlueResponse(BaseResponse):
if "CatalogId" in self.parameters: if "CatalogId" in self.parameters:
database_input["CatalogId"] = self.parameters.get("CatalogId") # type: ignore database_input["CatalogId"] = self.parameters.get("CatalogId") # type: ignore
self.glue_backend.create_database( self.glue_backend.create_database(
database_name, database_input, self.parameters.get("Tags") database_name,
) # type: ignore[arg-type] database_input, # type: ignore[arg-type]
self.parameters.get("Tags"), # type: ignore[arg-type]
)
return "" return ""
def get_database(self) -> str: def get_database(self) -> str:
@ -136,8 +138,8 @@ class GlueResponse(BaseResponse):
table_name = self.parameters.get("TableName") table_name = self.parameters.get("TableName")
expression = self.parameters.get("Expression") expression = self.parameters.get("Expression")
partitions = self.glue_backend.get_partitions( partitions = self.glue_backend.get_partitions(
database_name, database_name, # type: ignore[arg-type]
table_name, table_name, # type: ignore[arg-type]
expression, # type: ignore[arg-type] expression, # type: ignore[arg-type]
) )
@ -158,8 +160,8 @@ class GlueResponse(BaseResponse):
partitions_to_get = self.parameters.get("PartitionsToGet") partitions_to_get = self.parameters.get("PartitionsToGet")
partitions = self.glue_backend.batch_get_partition( partitions = self.glue_backend.batch_get_partition(
database_name, database_name, # type: ignore[arg-type]
table_name, table_name, # type: ignore[arg-type]
partitions_to_get, # type: ignore[arg-type] partitions_to_get, # type: ignore[arg-type]
) )
@ -178,8 +180,8 @@ class GlueResponse(BaseResponse):
table_name = self.parameters.get("TableName") table_name = self.parameters.get("TableName")
partition_input = self.parameters.get("PartitionInputList") partition_input = self.parameters.get("PartitionInputList")
errors_output = self.glue_backend.batch_create_partition( errors_output = self.glue_backend.batch_create_partition(
database_name, database_name, # type: ignore[arg-type]
table_name, table_name, # type: ignore[arg-type]
partition_input, # type: ignore[arg-type] partition_input, # type: ignore[arg-type]
) )
@ -196,9 +198,9 @@ class GlueResponse(BaseResponse):
part_to_update = self.parameters.get("PartitionValueList") part_to_update = self.parameters.get("PartitionValueList")
self.glue_backend.update_partition( self.glue_backend.update_partition(
database_name, database_name, # type: ignore[arg-type]
table_name, table_name, # type: ignore[arg-type]
part_input, part_input, # type: ignore[arg-type]
part_to_update, # type: ignore[arg-type] part_to_update, # type: ignore[arg-type]
) )
return "" return ""
@ -209,8 +211,8 @@ class GlueResponse(BaseResponse):
entries = self.parameters.get("Entries") entries = self.parameters.get("Entries")
errors_output = self.glue_backend.batch_update_partition( errors_output = self.glue_backend.batch_update_partition(
database_name, database_name, # type: ignore[arg-type]
table_name, table_name, # type: ignore[arg-type]
entries, # type: ignore[arg-type] entries, # type: ignore[arg-type]
) )
@ -234,8 +236,8 @@ class GlueResponse(BaseResponse):
parts = self.parameters.get("PartitionsToDelete") parts = self.parameters.get("PartitionsToDelete")
errors_output = self.glue_backend.batch_delete_partition( errors_output = self.glue_backend.batch_delete_partition(
database_name, database_name, # type: ignore[arg-type]
table_name, table_name, # type: ignore[arg-type]
parts, # type: ignore[arg-type] parts, # type: ignore[arg-type]
) )

4
moto/greengrass/models.py
View File

@ -916,9 +916,9 @@ class GreengrassBackend(BaseBackend):
return False return False
@staticmethod @staticmethod
def _validate_subscription_target_or_source( def _validate_subscription_target_or_source( # type: ignore[misc]
subscriptions: List[Dict[str, Any]], subscriptions: List[Dict[str, Any]],
) -> None: # type: ignore[misc] ) -> None:
target_errors: List[str] = [] target_errors: List[str] = []
source_errors: List[str] = [] source_errors: List[str] = []

92
moto/greengrass/responses.py
View File

@ -16,9 +16,9 @@ class GreengrassResponse(BaseResponse):
def greengrass_backend(self) -> GreengrassBackend: def greengrass_backend(self) -> GreengrassBackend:
return greengrass_backends[self.current_account][self.region] return greengrass_backends[self.current_account][self.region]
def core_definitions( def core_definitions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -45,9 +45,9 @@ class GreengrassResponse(BaseResponse):
) )
return 201, {"status": 201}, json.dumps(res.to_dict()) return 201, {"status": 201}, json.dumps(res.to_dict())
def core_definition( def core_definition( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -81,9 +81,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps({}) return 200, {"status": 200}, json.dumps({})
def core_definition_versions( def core_definition_versions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -110,9 +110,9 @@ class GreengrassResponse(BaseResponse):
json.dumps({"Versions": [core_def_ver.to_dict() for core_def_ver in res]}), json.dumps({"Versions": [core_def_ver.to_dict() for core_def_ver in res]}),
) )
def core_definition_version( def core_definition_version( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -127,9 +127,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps(res.to_dict(include_detail=True)) return 200, {"status": 200}, json.dumps(res.to_dict(include_detail=True))
def device_definitions( def device_definitions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -160,9 +160,9 @@ class GreengrassResponse(BaseResponse):
), ),
) )
def device_definition_versions( def device_definition_versions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -193,9 +193,9 @@ class GreengrassResponse(BaseResponse):
), ),
) )
def device_definition( def device_definition( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -229,9 +229,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps({}) return 200, {"status": 200}, json.dumps({})
def device_definition_version( def device_definition_version( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -246,9 +246,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps(res.to_dict(include_detail=True)) return 200, {"status": 200}, json.dumps(res.to_dict(include_detail=True))
def resource_definitions( def resource_definitions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -273,9 +273,9 @@ class GreengrassResponse(BaseResponse):
json.dumps({"Definitions": [i.to_dict() for i in res]}), json.dumps({"Definitions": [i.to_dict() for i in res]}),
) )
def resource_definition( def resource_definition( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -309,9 +309,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps({}) return 200, {"status": 200}, json.dumps({})
def resource_definition_versions( def resource_definition_versions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -343,9 +343,9 @@ class GreengrassResponse(BaseResponse):
), ),
) )
def resource_definition_version( def resource_definition_version( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -360,9 +360,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps(res.to_dict()) return 200, {"status": 200}, json.dumps(res.to_dict())
def function_definitions( def function_definitions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -389,9 +389,9 @@ class GreengrassResponse(BaseResponse):
), ),
) )
def function_definition( def function_definition( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -425,9 +425,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps({}) return 200, {"status": 200}, json.dumps({})
def function_definition_versions( def function_definition_versions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -456,9 +456,9 @@ class GreengrassResponse(BaseResponse):
versions = [i.to_dict() for i in res.values()] versions = [i.to_dict() for i in res.values()]
return 200, {"status": 200}, json.dumps({"Versions": versions}) return 200, {"status": 200}, json.dumps({"Versions": versions})
def function_definition_version( def function_definition_version( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -473,9 +473,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps(res.to_dict()) return 200, {"status": 200}, json.dumps(res.to_dict())
def subscription_definitions( def subscription_definitions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -507,9 +507,9 @@ class GreengrassResponse(BaseResponse):
), ),
) )
def subscription_definition( def subscription_definition( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -543,9 +543,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps({}) return 200, {"status": 200}, json.dumps({})
def subscription_definition_versions( def subscription_definition_versions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -571,9 +571,9 @@ class GreengrassResponse(BaseResponse):
versions = [i.to_dict() for i in res.values()] versions = [i.to_dict() for i in res.values()]
return 200, {"status": 200}, json.dumps({"Versions": versions}) return 200, {"status": 200}, json.dumps({"Versions": versions})
def subscription_definition_version( def subscription_definition_version( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -643,9 +643,9 @@ class GreengrassResponse(BaseResponse):
self.greengrass_backend.update_group(group_id=group_id, name=name) self.greengrass_backend.update_group(group_id=group_id, name=name)
return 200, {"status": 200}, json.dumps({}) return 200, {"status": 200}, json.dumps({})
def group_versions( def group_versions( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":
@ -742,9 +742,9 @@ class GreengrassResponse(BaseResponse):
json.dumps({"Deployments": deployments}), json.dumps({"Deployments": deployments}),
) )
def deployment_satus( def deployment_satus( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "GET": if self.method == "GET":
@ -760,9 +760,9 @@ class GreengrassResponse(BaseResponse):
) )
return 200, {"status": 200}, json.dumps(res.to_dict()) return 200, {"status": 200}, json.dumps(res.to_dict())
def deployments_reset( def deployments_reset( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if self.method == "POST": if self.method == "POST":

4
moto/iam/models.py
View File

@ -463,9 +463,9 @@ class AWSManagedPolicy(ManagedPolicy):
"""AWS-managed policy.""" """AWS-managed policy."""
@classmethod @classmethod
def from_data( def from_data( # type: ignore[misc]
cls, name: str, account_id: str, data: Dict[str, Any] cls, name: str, account_id: str, data: Dict[str, Any]
) -> "AWSManagedPolicy": # type: ignore[misc] ) -> "AWSManagedPolicy":
return cls( return cls(
name, name,
account_id=account_id, account_id=account_id,

14
moto/iam/policy_validation.py
View File

@ -222,9 +222,10 @@ class BaseIAMPolicyValidator:
) )
@staticmethod @staticmethod
def _validate_string_or_list_of_strings_syntax( def _validate_string_or_list_of_strings_syntax( # type: ignore[misc]
statement: Dict[str, Any], key: str statement: Dict[str, Any],
) -> None: # type: ignore[misc] key: str,
) -> None:
if key in statement: if key in statement:
assert isinstance(statement[key], (str, list)) assert isinstance(statement[key], (str, list))
if isinstance(statement[key], list): if isinstance(statement[key], list):
@ -456,9 +457,10 @@ class BaseIAMPolicyValidator:
assert resource[2] != "" assert resource[2] != ""
@staticmethod @staticmethod
def _legacy_parse_condition( def _legacy_parse_condition( # type: ignore[misc]
condition_key: str, condition_value: Dict[str, Any] condition_key: str,
) -> None: # type: ignore[misc] condition_value: Dict[str, Any],
) -> None:
stripped_condition_key = IAMPolicyDocumentValidator._strip_condition_key( stripped_condition_key = IAMPolicyDocumentValidator._strip_condition_key(
condition_key condition_key
) )

4
moto/iotdata/models.py
View File

@ -44,9 +44,9 @@ class FakeShadow(BaseModel):
) )
@classmethod @classmethod
def create_from_previous_version( def create_from_previous_version( # type: ignore[misc]
cls, previous_shadow: Optional["FakeShadow"], payload: Optional[Dict[str, Any]] cls, previous_shadow: Optional["FakeShadow"], payload: Optional[Dict[str, Any]]
) -> "FakeShadow": # type: ignore[misc] ) -> "FakeShadow":
""" """
set None to payload when you want to delete shadow set None to payload when you want to delete shadow
""" """

4
moto/kinesis/models.py
View File

@ -734,8 +734,8 @@ class KinesisBackend(BaseBackend):
data = record.get("Data") data = record.get("Data")
sequence_number, shard_id = stream.put_record( sequence_number, shard_id = stream.put_record(
partition_key, partition_key, # type: ignore[arg-type]
explicit_hash_key, explicit_hash_key, # type: ignore[arg-type]
data, # type: ignore[arg-type] data, # type: ignore[arg-type]
) )
response["Records"].append( response["Records"].append(

4
moto/opsworks/models.py
View File

@ -588,9 +588,9 @@ class OpsWorksBackend(BaseBackend):
raise ResourceNotFoundException(", ".join(unknown_apps)) raise ResourceNotFoundException(", ".join(unknown_apps))
return [self.apps[id].to_dict() for id in app_ids] return [self.apps[id].to_dict() for id in app_ids]
def describe_instances( def describe_instances( # type: ignore[return]
self, instance_ids: List[str], layer_id: str, stack_id: str self, instance_ids: List[str], layer_id: str, stack_id: str
) -> List[Dict[str, Any]]: # type: ignore[return] ) -> List[Dict[str, Any]]:
if len(list(filter(None, (instance_ids, layer_id, stack_id)))) != 1: if len(list(filter(None, (instance_ids, layer_id, stack_id)))) != 1:
raise ValidationException( raise ValidationException(
"Please provide either one or more " "Please provide either one or more "

8
moto/rds/models.py
View File

@ -2754,9 +2754,9 @@ class RDSBackend(BaseBackend):
"InvalidParameterValue", f"Invalid resource name: {arn}" "InvalidParameterValue", f"Invalid resource name: {arn}"
) )
def add_tags_to_resource( def add_tags_to_resource( # type: ignore[return]
self, arn: str, tags: List[Dict[str, str]] self, arn: str, tags: List[Dict[str, str]]
) -> List[Dict[str, str]]: # type: ignore[return] ) -> List[Dict[str, str]]:
if self.arn_regex.match(arn): if self.arn_regex.match(arn):
arn_breakdown = arn.split(":") arn_breakdown = arn.split(":")
resource_type = arn_breakdown[-2] resource_type = arn_breakdown[-2]
@ -2813,9 +2813,9 @@ class RDSBackend(BaseBackend):
raise InvalidParameterCombination(str(e)) raise InvalidParameterCombination(str(e))
@staticmethod @staticmethod
def _merge_tags( def _merge_tags( # type: ignore[misc]
old_tags: List[Dict[str, Any]], new_tags: List[Dict[str, Any]] old_tags: List[Dict[str, Any]], new_tags: List[Dict[str, Any]]
) -> List[Dict[str, Any]]: # type: ignore[misc] ) -> List[Dict[str, Any]]:
tags_dict = dict() tags_dict = dict()
tags_dict.update({d["Key"]: d["Value"] for d in old_tags}) tags_dict.update({d["Key"]: d["Value"] for d in old_tags})
tags_dict.update({d["Key"]: d["Value"] for d in new_tags}) tags_dict.update({d["Key"]: d["Value"] for d in new_tags})

2
moto/resourcegroupstaggingapi/models.py
View File

@ -23,8 +23,8 @@ from moto.s3.models import S3Backend, s3_backends
from moto.sns.models import SNSBackend, sns_backends from moto.sns.models import SNSBackend, sns_backends
from moto.sqs.models import SQSBackend, sqs_backends from moto.sqs.models import SQSBackend, sqs_backends
from moto.ssm.models import SimpleSystemManagerBackend, ssm_backends from moto.ssm.models import SimpleSystemManagerBackend, ssm_backends
from moto.workspaces.models import WorkSpacesBackend, workspaces_backends
from moto.utilities.tagging_service import TaggingService from moto.utilities.tagging_service import TaggingService
from moto.workspaces.models import WorkSpacesBackend, workspaces_backends
# Left: EC2 ElastiCache RDS ELB CloudFront Lambda EMR Glacier Kinesis Redshift Route53 # Left: EC2 ElastiCache RDS ELB CloudFront Lambda EMR Glacier Kinesis Redshift Route53
# StorageGateway DynamoDB MachineLearning ACM DirectConnect DirectoryService CloudHSM # StorageGateway DynamoDB MachineLearning ACM DirectConnect DirectoryService CloudHSM

48
moto/route53/responses.py
View File

@ -36,9 +36,9 @@ class Route53(BaseResponse):
def backend(self) -> Route53Backend: def backend(self) -> Route53Backend:
return route53_backends[self.current_account]["global"] return route53_backends[self.current_account]["global"]
def list_or_create_hostzone_response( def list_or_create_hostzone_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
# Set these here outside the scope of the try/except # Set these here outside the scope of the try/except
@ -136,9 +136,9 @@ class Route53(BaseResponse):
template = Template(GET_HOSTED_ZONE_COUNT_RESPONSE) template = Template(GET_HOSTED_ZONE_COUNT_RESPONSE)
return 200, headers, template.render(zone_count=num_zones, xmlns=XMLNS) return 200, headers, template.render(zone_count=num_zones, xmlns=XMLNS)
def get_or_delete_hostzone_response( def get_or_delete_hostzone_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
zoneid = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1] zoneid = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
@ -158,9 +158,9 @@ class Route53(BaseResponse):
template = Template(UPDATE_HOSTED_ZONE_COMMENT_RESPONSE) template = Template(UPDATE_HOSTED_ZONE_COMMENT_RESPONSE)
return 200, headers, template.render(zone=zone) return 200, headers, template.render(zone=zone)
def get_dnssec_response( def get_dnssec_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
# returns static response # returns static response
# TODO: implement enable/disable dnssec apis # TODO: implement enable/disable dnssec apis
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
@ -212,9 +212,9 @@ class Route53(BaseResponse):
template = Template(DISASSOCIATE_VPC_RESPONSE) template = Template(DISASSOCIATE_VPC_RESPONSE)
return 200, headers, template.render(comment=comment) return 200, headers, template.render(comment=comment)
def rrset_response( def rrset_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
method = request.method method = request.method
@ -285,9 +285,9 @@ class Route53(BaseResponse):
) )
return 200, headers, r_template return 200, headers, r_template
def health_check_response1( def health_check_response1( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
method = request.method method = request.method
@ -327,9 +327,9 @@ class Route53(BaseResponse):
template.render(health_checks=health_checks, xmlns=XMLNS), template.render(health_checks=health_checks, xmlns=XMLNS),
) )
def health_check_response2( def health_check_response2( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
method = request.method method = request.method
@ -365,9 +365,9 @@ class Route53(BaseResponse):
template = Template(UPDATE_HEALTH_CHECK_RESPONSE) template = Template(UPDATE_HEALTH_CHECK_RESPONSE)
return 200, headers, template.render(health_check=health_check) return 200, headers, template.render(health_check=health_check)
def health_check_status_response( def health_check_status_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
method = request.method method = request.method
@ -402,9 +402,9 @@ class Route53(BaseResponse):
f"The action for {action} has not been implemented for route 53" f"The action for {action} has not been implemented for route 53"
) )
def list_or_change_tags_for_resource_request( def list_or_change_tags_for_resource_request( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
id_ = self.parsed_url.path.split("/")[-1] id_ = self.parsed_url.path.split("/")[-1]
@ -439,9 +439,9 @@ class Route53(BaseResponse):
template = Template(GET_CHANGE_RESPONSE) template = Template(GET_CHANGE_RESPONSE)
return 200, headers, template.render(change_id=change_id, xmlns=XMLNS) return 200, headers, template.render(change_id=change_id, xmlns=XMLNS)
def list_or_create_query_logging_config_response( def list_or_create_query_logging_config_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "POST": if request.method == "POST":
@ -488,9 +488,9 @@ class Route53(BaseResponse):
), ),
) )
def get_or_delete_query_logging_config_response( def get_or_delete_query_logging_config_response( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
query_logging_config_id = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1] query_logging_config_id = self.parsed_url.path.rstrip("/").rsplit("/", 1)[1]
@ -509,9 +509,9 @@ class Route53(BaseResponse):
self.backend.delete_query_logging_config(query_logging_config_id) self.backend.delete_query_logging_config(query_logging_config_id)
return 200, headers, "" return 200, headers, ""
def reusable_delegation_sets( def reusable_delegation_sets( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "GET": if request.method == "GET":
delegation_sets = self.backend.list_reusable_delegation_sets() delegation_sets = self.backend.list_reusable_delegation_sets()
@ -541,9 +541,9 @@ class Route53(BaseResponse):
template.render(delegation_set=delegation_set), template.render(delegation_set=delegation_set),
) )
def reusable_delegation_set( def reusable_delegation_set( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
ds_id = self.parsed_url.path.rstrip("/").rsplit("/")[-1] ds_id = self.parsed_url.path.rstrip("/").rsplit("/")[-1]
if request.method == "GET": if request.method == "GET":

12
moto/s3/models.py
View File

@ -374,13 +374,13 @@ class FakeKey(BaseModel, ManagedState):
now = utcnow() now = utcnow()
try: try:
until = datetime.datetime.strptime( until = datetime.datetime.strptime(
self.lock_until, self.lock_until, # type: ignore
"%Y-%m-%dT%H:%M:%SZ", # type: ignore "%Y-%m-%dT%H:%M:%SZ",
) )
except ValueError: except ValueError:
until = datetime.datetime.strptime( until = datetime.datetime.strptime(
self.lock_until, self.lock_until, # type: ignore
"%Y-%m-%dT%H:%M:%S.%fZ", # type: ignore "%Y-%m-%dT%H:%M:%S.%fZ",
) )
if until > now: if until > now:
@ -478,11 +478,11 @@ class FakeMultipart(BaseModel):
raise NoSuchUpload(upload_id=part_id) raise NoSuchUpload(upload_id=part_id)
key = FakeKey( key = FakeKey(
part_id, part_id, # type: ignore
value, value,
account_id=self.account_id, account_id=self.account_id,
encryption=self.sse_encryption, encryption=self.sse_encryption,
kms_key_id=self.kms_key_id, # type: ignore kms_key_id=self.kms_key_id,
) )
if part_id in self.parts: if part_id in self.parts:
# We're overwriting the current part - dispose of it first # We're overwriting the current part - dispose of it first

12
moto/s3control/responses.py
View File

@ -19,9 +19,9 @@ class S3ControlResponse(BaseResponse):
def backend(self) -> S3ControlBackend: def backend(self) -> S3ControlBackend:
return s3control_backends[self.current_account]["global"] return s3control_backends[self.current_account]["global"]
def public_access_block( def public_access_block( # type: ignore
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
try: try:
if request.method == "GET": if request.method == "GET":
@ -70,9 +70,9 @@ class S3ControlResponse(BaseResponse):
if request.method == "DELETE": if request.method == "DELETE":
return self.delete_access_point(full_url) return self.delete_access_point(full_url)
def access_point_policy( def access_point_policy( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "PUT": if request.method == "PUT":
return self.create_access_point_policy(full_url) return self.create_access_point_policy(full_url)
@ -81,9 +81,9 @@ class S3ControlResponse(BaseResponse):
if request.method == "DELETE": if request.method == "DELETE":
return self.delete_access_point_policy(full_url) return self.delete_access_point_policy(full_url)
def access_point_policy_status( def access_point_policy_status( # type: ignore[return]
self, request: Any, full_url: str, headers: Any self, request: Any, full_url: str, headers: Any
) -> TYPE_RESPONSE: # type: ignore[return] ) -> TYPE_RESPONSE:
self.setup_class(request, full_url, headers) self.setup_class(request, full_url, headers)
if request.method == "PUT": if request.method == "PUT":
return self.create_access_point(full_url) return self.create_access_point(full_url)

6
moto/ses/responses.py
View File

@ -143,9 +143,9 @@ class EmailResponse(BaseResponse):
message = self.backend.send_bulk_templated_email( message = self.backend.send_bulk_templated_email(
source, source,
template, template, # type: ignore
template_data, template_data, # type: ignore
destinations, # type: ignore destinations,
) )
template = self.response_template(SEND_BULK_TEMPLATED_EMAIL_RESPONSE) template = self.response_template(SEND_BULK_TEMPLATED_EMAIL_RESPONSE)
result = template.render(message=message) result = template.render(message=message)

2
moto/ses/template.py
View File

@ -46,7 +46,7 @@ class EachBlockProcessor(BlockProcessor):
_processor = get_processor(self.tokenizer)( _processor = get_processor(self.tokenizer)(
self.template, self.template,
template_data, template_data, # type: ignore
self.tokenizer, # type: ignore self.tokenizer, # type: ignore
) )
# If we've reached the end, we should stop processing # If we've reached the end, we should stop processing

4
moto/stepfunctions/parser/models.py
View File

@ -106,9 +106,9 @@ class StepFunctionsParserBackend(StepFunctionBackend):
raise InvalidToken() raise InvalidToken()
def send_task_success( def send_task_success(
self, task_token: TaskToken, output: SensitiveData self, task_token: TaskToken, outcome: SensitiveData
) -> SendTaskSuccessOutput: ) -> SendTaskSuccessOutput:
outcome = CallbackOutcomeSuccess(callback_id=task_token, output=output) outcome = CallbackOutcomeSuccess(callback_id=task_token, output=outcome)
running_executions = self._get_executions(ExecutionStatus.RUNNING) running_executions = self._get_executions(ExecutionStatus.RUNNING)
for execution in running_executions: for execution in running_executions:
try: try:

2
moto/sts/models.py
View File

@ -1,7 +1,7 @@
import datetime import datetime
import re import re
from base64 import b64decode from base64 import b64decode
from typing import Any, Dict, List, Optional, Tuple from typing import Any, List, Optional, Tuple
import xmltodict import xmltodict

4
moto/swf/models/domain.py
View File

@ -61,9 +61,9 @@ class Domain(BaseModel):
"configuration": {"workflowExecutionRetentionPeriodInDays": self.retention}, "configuration": {"workflowExecutionRetentionPeriodInDays": self.retention},
} }
def get_type( def get_type( # type: ignore
self, kind: str, name: str, version: str, ignore_empty: bool = False self, kind: str, name: str, version: str, ignore_empty: bool = False
) -> "GenericType": # type: ignore ) -> "GenericType":
try: try:
return self.types[kind][name][version] return self.types[kind][name][version]
except KeyError: except KeyError:

4
tests/test_core/test_decorator_calls.py
View File

@ -85,9 +85,9 @@ def test_decorater_wrapped_gets_set() -> None:
Moto decorator's __wrapped__ should get set to the tests function Moto decorator's __wrapped__ should get set to the tests function
""" """
assert ( assert (
test_decorater_wrapped_gets_set.__wrapped__.__name__ test_decorater_wrapped_gets_set.__wrapped__.__name__ # type: ignore
== "test_decorater_wrapped_gets_set" == "test_decorater_wrapped_gets_set"
) # type: ignore )
@mock_aws @mock_aws

8
tests/test_logs/test_export_tasks.py
View File

@ -143,8 +143,8 @@ def test_create_export_task_happy_path(logs, s3, log_group_name, bucket_name):
@pytest.mark.aws_verified @pytest.mark.aws_verified
def test_create_export_task_raises_ClientError_when_bucket_not_found( def test_create_export_task_raises_ClientError_when_bucket_not_found(
logs, logs,
log_group_name, # pylint: disable=redefined-outer-name log_group_name,
): ): # pylint: disable=redefined-outer-name
destination = "368a7022dea3dd621" destination = "368a7022dea3dd621"
fromTime = 1611316574 fromTime = 1611316574
to = 1642852574 to = 1642852574
@ -166,8 +166,8 @@ def test_create_export_task_raises_ClientError_when_bucket_not_found(
@pytest.mark.aws_verified @pytest.mark.aws_verified
def test_create_export_raises_ResourceNotFoundException_log_group_not_found( def test_create_export_raises_ResourceNotFoundException_log_group_not_found(
logs, logs,
bucket_name, # pylint: disable=redefined-outer-name bucket_name,
): ): # pylint: disable=redefined-outer-name
with pytest.raises(logs.exceptions.ResourceNotFoundException) as exc: with pytest.raises(logs.exceptions.ResourceNotFoundException) as exc:
logs.create_export_task( logs.create_export_task(
logGroupName=f"/aws/nonexisting/{str(uuid4())[0:6]}", logGroupName=f"/aws/nonexisting/{str(uuid4())[0:6]}",

2
tests/test_resourcegroupstaggingapi/test_resourcegroupstaggingapi.py
View File

@ -886,8 +886,6 @@ def test_get_resources_sns():
@mock_aws @mock_aws
def test_get_resources_ssm(): def test_get_resources_ssm():
import json
import yaml import yaml
from tests.test_ssm.test_ssm_docs import _get_yaml_template from tests.test_ssm.test_ssm_docs import _get_yaml_template