moto 5.0.14.dev5__tar.gz → 5.0.14.dev7__tar.gz

{moto-5.0.14.dev5/moto.egg-info → moto-5.0.14.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moto
-Version: 5.0.14.dev5
+Version: 5.0.14.dev7
 Home-page: https://github.com/getmoto/moto
 Author: Steve Pulec
 Author-email: spulec@gmail.com

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/__init__.py

@@ -1,4 +1,4 @@
 from moto.core.decorator import mock_aws as mock_aws
 
 __title__ = "moto"
-__version__ = "5.0.14.dev5"
+__version__ = "5.0.14.dev7"

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/appconfig/responses.py

@@ -8,15 +8,6 @@ from .models import AppConfigBackend, appconfig_backends
 
 
 class AppConfigResponse(BaseResponse):
-    def tags(self, request: Any, full_url: str, headers: Any) -> str:  # type: ignore[return]
-        self.setup_class(request, full_url, headers)
-        if request.method == "GET":
-            return self.list_tags_for_resource()
-        if request.method == "POST":
-            return self.tag_resource()
-        if request.method == "DELETE":
-            return self.untag_resource()
-
     def __init__(self) -> None:
         super().__init__(service_name="appconfig")
 

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/appconfig/urls.py

@@ -15,10 +15,6 @@ url_paths = {
     "{0}/applications/(?P<app_id>[^/]+)/configurationprofiles/(?P<config_profile_id>[^/]+)/hostedconfigurationversions$": AppConfigResponse.dispatch,
     "{0}/applications/(?P<app_id>[^/]+)/configurationprofiles/(?P<config_profile_id>[^/]+)/hostedconfigurationversions/(?P<version>[^/]+)$": AppConfigResponse.dispatch,
     "{0}/tags/(?P<app_id>.+)$": AppConfigResponse.dispatch,
-    "{0}/tags/(?P<arn_part_1>[^/]+)/(?P<app_id>[^/]+)$": AppConfigResponse.method_dispatch(
-        AppConfigResponse.tags  # type: ignore
-    ),
-    "{0}/tags/(?P<arn_part_1>[^/]+)/(?P<app_id>[^/]+)/configurationprofile/(?P<cp_id>[^/]+)$": AppConfigResponse.method_dispatch(
-        AppConfigResponse.tags  # type: ignore
-    ),
+    "{0}/tags/(?P<arn_part_1>[^/]+)/(?P<app_id>[^/]+)$": AppConfigResponse.dispatch,
+    "{0}/tags/(?P<arn_part_1>[^/]+)/(?P<app_id>[^/]+)/configurationprofile/(?P<cp_id>[^/]+)$": AppConfigResponse.dispatch,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/cognitoidp/responses.py

@@ -1,9 +1,9 @@
 import json
-import os
 import re
-from typing import Any, Dict, Tuple
+from typing import Any, Dict
 
-from moto.core.responses import BaseResponse
+from moto.core.responses import TYPE_RESPONSE, BaseResponse
+from moto.utilities.utils import load_resource
 
 from .exceptions import InvalidParameterException
 from .models import (
@@ -674,16 +674,17 @@ class CognitoIdpResponse(BaseResponse):
 
 
 class CognitoIdpJsonWebKeyResponse(BaseResponse):
+    json_web_key = json.dumps(
+        load_resource(__name__, "resources/jwks-public.json")
+    ).encode("utf-8")
+
     def __init__(self) -> None:
-        with open(
-            os.path.join(os.path.dirname(__file__), "resources/jwks-public.json")
-        ) as f:
-            self.json_web_key = f.read()
-
-    def serve_json_web_key(
-        self,
-        request: Any,  # pylint: disable=unused-argument
-        full_url: str,  # pylint: disable=unused-argument
-        headers: Any,  # pylint: disable=unused-argument
-    ) -> Tuple[int, Dict[str, str], str]:
-        return 200, {"Content-Type": "application/json"}, self.json_web_key
+        super().__init__(service_name="cognito-idp")
+
+    @staticmethod
+    def serve_json_web_key(*args) -> TYPE_RESPONSE:  # type: ignore
+        return (
+            200,
+            {"Content-Type": "application/json"},
+            CognitoIdpJsonWebKeyResponse.json_web_key,
+        )

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/cognitoidp/urls.py

@@ -4,7 +4,5 @@ url_bases = [r"https?://cognito-idp\.(.+)\.amazonaws.com"]
 
 url_paths = {
     "{0}/$": CognitoIdpResponse.dispatch,
-    "{0}/(?P<user_pool_id>[^/]+)/.well-known/jwks.json$": CognitoIdpJsonWebKeyResponse.method_dispatch(
-        CognitoIdpJsonWebKeyResponse.serve_json_web_key
-    ),
+    "{0}/(?P<user_pool_id>[^/]+)/.well-known/jwks.json$": CognitoIdpJsonWebKeyResponse.serve_json_web_key,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/ebs/models.py

@@ -74,6 +74,9 @@ class EBSBackend(BaseBackend):
     def start_snapshot(
         self, volume_size: int, tags: Optional[List[Dict[str, str]]], description: str
     ) -> EBSSnapshot:
+        """
+        The following parameters are not yet implemented: ParentSnapshotId, ClientToken, Encrypted, KmsKeyArn, Timeout
+        """
         zone_name = f"{self.region_name}a"
         vol = self.ec2_backend.create_volume(size=volume_size, zone_name=zone_name)
         snapshot = self.ec2_backend.create_snapshot(
@@ -86,6 +89,9 @@ class EBSBackend(BaseBackend):
         return ebs_snapshot
 
     def complete_snapshot(self, snapshot_id: str) -> Dict[str, str]:
+        """
+        The following parameters are not yet supported: ChangedBlocksCount, Checksum, ChecksumAlgorithm, ChecksumAggregationMethod
+        """
         self.snapshots[snapshot_id].status = "completed"
         return {"Status": "completed"}
 
@@ -98,6 +104,10 @@ class EBSBackend(BaseBackend):
         checksum_algorithm: str,
         data_length: str,
     ) -> Tuple[str, str]:
+        """
+        The following parameters are currently not taken into account: DataLength, Progress.
+        The Checksum and ChecksumAlgorithm are taken at face-value, but no validation takes place.
+        """
         snapshot = self.snapshots[snapshot_id]
         snapshot.put_block(
             block_index, block_data, checksum, checksum_algorithm, data_length
@@ -119,9 +129,9 @@ class EBSBackend(BaseBackend):
         """
         snapshot1 = self.snapshots[first_snapshot_id]
         snapshot2 = self.snapshots[second_snapshot_id]
-        changed_blocks: Dict[str, Tuple[str, Optional[str]]] = (
-            dict()
-        )  # {idx: (token1, token2), ..}
+        changed_blocks: Dict[
+            str, Tuple[str, Optional[str]]
+        ] = {}  # {idx: (token1, token2), ..}
         for idx in snapshot1.blocks:
             block1 = snapshot1.blocks[idx]
             if idx in snapshot2.blocks:
@@ -134,6 +144,9 @@ class EBSBackend(BaseBackend):
         return changed_blocks, snapshot1
 
     def list_snapshot_blocks(self, snapshot_id: str) -> EBSSnapshot:
+        """
+        The following parameters are not yet implemented: NextToken, MaxResults, StartingBlockIndex
+        """
         return self.snapshots[snapshot_id]
 
 

moto-5.0.14.dev7/moto/ebs/responses.py

@@ -0,0 +1,114 @@
+"""Handles incoming ebs requests, invokes methods, returns responses."""
+
+import json
+from typing import Any
+
+from moto.core.common_types import TYPE_RESPONSE
+from moto.core.responses import BaseResponse
+
+from .models import EBSBackend, ebs_backends
+
+
+class EBSResponse(BaseResponse):
+    """Handler for EBS requests and responses."""
+
+    def __init__(self) -> None:
+        super().__init__(service_name="ebs")
+
+    def setup_class(self, request: Any, full_url: str, headers: Any) -> None:  # type: ignore
+        super().setup_class(request, full_url, headers, use_raw_body=True)
+
+    @property
+    def ebs_backend(self) -> EBSBackend:
+        """Return backend instance specific for this region."""
+        return ebs_backends[self.current_account][self.region]
+
+    def start_snapshot(self) -> str:
+        params = json.loads(self.body)
+        volume_size = params.get("VolumeSize")
+        tags = params.get("Tags")
+        description = params.get("Description")
+        snapshot = self.ebs_backend.start_snapshot(
+            volume_size=volume_size,
+            tags=tags,
+            description=description,
+        )
+        return json.dumps(snapshot.to_json())
+
+    def complete_snapshot(self) -> TYPE_RESPONSE:
+        snapshot_id = self.parsed_url.path.split("/")[-1]
+        status = self.ebs_backend.complete_snapshot(snapshot_id=snapshot_id)
+        return 202, {"status": 202}, json.dumps(status)
+
+    def put_snapshot_block(self) -> TYPE_RESPONSE:
+        snapshot_id = self.parsed_url.path.split("/")[-3]
+        block_index = self.parsed_url.path.split("/")[-1]
+        block_data = self.body
+        headers = {k.lower(): v for k, v in self.headers.items()}
+        checksum = headers.get("x-amz-checksum")
+        checksum_algorithm = headers.get("x-amz-checksum-algorithm")
+        data_length = headers.get("x-amz-data-length")
+        checksum, checksum_algorithm = self.ebs_backend.put_snapshot_block(
+            snapshot_id=snapshot_id,
+            block_index=block_index,
+            block_data=block_data,
+            checksum=checksum,  # type: ignore
+            checksum_algorithm=checksum_algorithm,  # type: ignore
+            data_length=data_length,  # type: ignore
+        )
+        resp_headers = {
+            "status": 201,
+            "x-amz-Checksum": checksum,
+            "x-amz-Checksum-Algorithm": checksum_algorithm,
+        }
+        return 201, resp_headers, "{}"
+
+    def get_snapshot_block(self) -> TYPE_RESPONSE:
+        snapshot_id = self.path.split("/")[-3]
+        block_index = self.path.split("/")[-1]
+        block = self.ebs_backend.get_snapshot_block(
+            snapshot_id=snapshot_id,
+            block_index=block_index,
+        )
+        headers = {
+            "x-amz-Checksum": block.checksum,
+            "x-amz-Checksum-Algorithm": block.checksum_algorithm,
+            "x-amz-Data-Length": block.data_length,
+        }
+        return 200, headers, block.block_data
+
+    def list_changed_blocks(self) -> str:
+        first_snapshot_id = self._get_params().get("firstSnapshotId")
+        second_snapshot_id = self.path.split("/")[-2]
+        changed_blocks, snapshot = self.ebs_backend.list_changed_blocks(
+            first_snapshot_id=first_snapshot_id,  # type: ignore[arg-type]
+            second_snapshot_id=second_snapshot_id,
+        )
+        blocks = [
+            {"BlockIndex": idx, "FirstBlockToken": x, "SecondBlockToken": y}
+            for idx, (x, y) in changed_blocks.items()
+        ]
+        return json.dumps(
+            dict(
+                ChangedBlocks=blocks,
+                VolumeSize=snapshot.volume_size,
+                BlockSize=snapshot.block_size,
+            )
+        )
+
+    def list_snapshot_blocks(self) -> str:
+        snapshot_id = self.path.split("/")[-2]
+        snapshot = self.ebs_backend.list_snapshot_blocks(
+            snapshot_id=snapshot_id,
+        )
+        blocks = [
+            {"BlockIndex": idx, "BlockToken": b.block_token}
+            for idx, b in snapshot.blocks.items()
+        ]
+        return json.dumps(
+            {
+                "Blocks": blocks,
+                "VolumeSize": snapshot.volume_size,
+                "BlockSize": snapshot.block_size,
+            }
+        )

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/ebs/urls.py

@@ -6,17 +6,9 @@ url_bases = [r"https?://ebs\.(.+)\.amazonaws\.com"]
 
 
 url_paths = {
-    "{0}/snapshots$": EBSResponse.method_dispatch(EBSResponse.snapshots),
-    "{0}/snapshots/completion/(?P<snapshot_id>[^/]+)$": EBSResponse.method_dispatch(
-        EBSResponse.complete_snapshot
-    ),
-    "{0}/snapshots/(?P<snapshot_id>[^/]+)/changedblocks$": EBSResponse.method_dispatch(
-        EBSResponse.snapshot_changed_blocks
-    ),
-    "{0}/snapshots/(?P<snapshot_id>[^/]+)/blocks$": EBSResponse.method_dispatch(
-        EBSResponse.snapshot_blocks
-    ),
-    "{0}/snapshots/(?P<snapshot_id>[^/]+)/blocks/(?P<block_idx>[^/]+)$": EBSResponse.method_dispatch(
-        EBSResponse.snapshot_block
-    ),
+    "{0}/snapshots$": EBSResponse.dispatch,
+    "{0}/snapshots/completion/(?P<snapshot_id>[^/]+)$": EBSResponse.dispatch,
+    "{0}/snapshots/(?P<snapshot_id>[^/]+)/changedblocks$": EBSResponse.dispatch,
+    "{0}/snapshots/(?P<snapshot_id>[^/]+)/blocks$": EBSResponse.dispatch,
+    "{0}/snapshots/(?P<snapshot_id>[^/]+)/blocks/(?P<block_idx>[^/]+)$": EBSResponse.dispatch,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/elastictranscoder/responses.py

@@ -1,6 +1,6 @@
 import json
 import re
-from typing import Any, Optional
+from typing import Optional
 
 from moto.core.common_types import TYPE_RESPONSE
 from moto.core.responses import BaseResponse
@@ -17,26 +17,6 @@ class ElasticTranscoderResponse(BaseResponse):
     def elastictranscoder_backend(self) -> ElasticTranscoderBackend:
         return elastictranscoder_backends[self.current_account][self.region]
 
-    def pipelines(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:
-        self.setup_class(request, full_url, headers)
-        if request.method == "POST":
-            return self.create_pipeline()
-        elif request.method == "GET":
-            return self.list_pipelines()
-        else:
-            return self.update_pipeline()
-
-    def individual_pipeline(
-        self, request: Any, full_url: str, headers: Any
-    ) -> TYPE_RESPONSE:
-        self.setup_class(request, full_url, headers)
-        if request.method == "GET":
-            return self.read_pipeline()
-        elif request.method == "DELETE":
-            return self.delete_pipeline()
-        else:
-            return self.update_pipeline()
-
     def create_pipeline(self) -> TYPE_RESPONSE:
         name = self._get_param("Name")
         input_bucket = self._get_param("InputBucket")
@@ -121,10 +101,10 @@ class ElasticTranscoderResponse(BaseResponse):
             json.dumps({"Pipeline": pipeline.to_dict(), "Warnings": warnings}),
         )
 
-    def delete_pipeline(self) -> TYPE_RESPONSE:
+    def delete_pipeline(self) -> str:
         _id = self.path.rsplit("/", 1)[-1]
         self.elastictranscoder_backend.delete_pipeline(pipeline_id=_id)
-        return 200, {}, "{}"
+        return "{}"
 
     def err(self, msg: str) -> TYPE_RESPONSE:
         return (

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/elastictranscoder/urls.py

@@ -6,10 +6,6 @@ url_bases = [
 
 
 url_paths = {
-    r"{0}/(?P<api_version>[^/]+)/pipelines/?$": ElasticTranscoderResponse.method_dispatch(
-        ElasticTranscoderResponse.pipelines
-    ),
-    r"{0}/(?P<api_version>[^/]+)/pipelines/(?P<pipeline_id>[^/]+)/?$": ElasticTranscoderResponse.method_dispatch(
-        ElasticTranscoderResponse.individual_pipeline
-    ),
+    r"{0}/(?P<api_version>[^/]+)/pipelines/?$": ElasticTranscoderResponse.dispatch,
+    r"{0}/(?P<api_version>[^/]+)/pipelines/(?P<pipeline_id>[^/]+)/?$": ElasticTranscoderResponse.dispatch,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/inspector2/responses.py

@@ -2,7 +2,6 @@ import json
 from typing import Any, Dict, List
 from urllib.parse import unquote
 
-from moto.core.common_types import TYPE_RESPONSE
 from moto.core.responses import BaseResponse
 
 from .models import Inspector2Backend, inspector2_backends
@@ -125,28 +124,19 @@ class Inspector2Response(BaseResponse):
         member = self.inspector2_backend.get_member(account_id)
         return json.dumps({"member": member.to_json()})
 
-    def list_tags_for_resource(self) -> TYPE_RESPONSE:
+    def list_tags_for_resource(self) -> str:
         arn = unquote(self.path.split("/tags/")[-1])
         tags = self.inspector2_backend.list_tags_for_resource(arn)
-        return 200, {}, json.dumps({"tags": tags})
+        return json.dumps({"tags": tags})
 
-    def tag_resource(self) -> TYPE_RESPONSE:
+    def tag_resource(self) -> str:
         resource_arn = unquote(self.path.split("/tags/")[-1])
         tags = self._get_param("tags")
         self.inspector2_backend.tag_resource(resource_arn=resource_arn, tags=tags)
-        return 200, {}, "{}"
+        return "{}"
 
-    def untag_resource(self) -> TYPE_RESPONSE:
+    def untag_resource(self) -> str:
         resource_arn = unquote(self.path.split("/tags/")[-1])
         tag_keys = self.querystring.get("tagKeys")
         self.inspector2_backend.untag_resource(resource_arn, tag_keys)  # type: ignore
-        return 200, {}, "{}"
-
-    def tags(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
-        self.setup_class(request, full_url, headers)
-        if request.method == "GET":
-            return self.list_tags_for_resource()
-        if request.method == "POST":
-            return self.tag_resource()
-        if request.method == "DELETE":
-            return self.untag_resource()
+        return "{}"

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/inspector2/urls.py

@@ -24,7 +24,5 @@ url_paths = {
     "{0}/status/batch/get$": Inspector2Response.dispatch,
     "{0}/organizationconfiguration/describe$": Inspector2Response.dispatch,
     "{0}/organizationconfiguration/update$": Inspector2Response.dispatch,
-    "{0}/tags/(?P<resource_arn>.+)$": Inspector2Response.method_dispatch(
-        Inspector2Response.tags
-    ),
+    "{0}/tags/(?P<resource_arn>.+)$": Inspector2Response.dispatch,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/instance_metadata/responses.py

@@ -15,8 +15,8 @@ class InstanceMetadataResponse(BaseResponse):
     def backends(self) -> None:
         pass
 
-    def metadata_response(
-        self,
+    @staticmethod
+    def metadata_response(  # type: ignore
         request: Any,  # pylint: disable=unused-argument
         full_url: str,
         headers: Any,

moto-5.0.14.dev7/moto/instance_metadata/urls.py

@@ -0,0 +1,7 @@
+from .responses import InstanceMetadataResponse
+
+url_bases = ["http://169.254.169.254"]
+
+url_paths = {
+    "{0}/(?P<path>.+)": InstanceMetadataResponse.metadata_response,
+}

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/iot/responses.py

@@ -477,18 +477,22 @@ class IoTResponse(BaseResponse):
         self.iot_backend.attach_policy(policy_name=policy_name, target=target)
         return json.dumps(dict())
 
-    def dispatch_attached_policies(
-        self, request: Any, full_url: str, headers: Any
+    @staticmethod
+    def dispatch_attached_policies(  # type: ignore
+        request: Any, full_url: str, headers: Any
     ) -> TYPE_RESPONSE:
+        response = IoTResponse()
         # This endpoint requires specialized handling because it has
         # a uri parameter containing forward slashes that is not
         # correctly url encoded when we're running in server mode.
         # https://github.com/pallets/flask/issues/900
-        self.setup_class(request, full_url, headers)
-        self.querystring["Action"] = ["ListAttachedPolicies"]
-        target = self.path.partition("/attached-policies/")[-1]
-        self.querystring["target"] = [unquote(target)] if "%" in target else [target]
-        return self.call_action()
+        response.setup_class(request, full_url, headers)
+        response.querystring["Action"] = ["ListAttachedPolicies"]
+        target = response.path.partition("/attached-policies/")[-1]
+        response.querystring["target"] = (
+            [unquote(target)] if "%" in target else [target]
+        )
+        return response.call_action()
 
     def list_attached_policies(self) -> str:
         principal = self._get_param("target")

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/iot/urls.py

@@ -8,18 +8,14 @@ url_paths = {
     # Paths for :class:`moto.core.models.MockAWS`
     #
     # This route requires special handling.
-    "{0}/attached-policies/(?P<target>.*)$": IoTResponse.method_dispatch(
-        IoTResponse.dispatch_attached_policies
-    ),
+    "{0}/attached-policies/(?P<target>.*)$": IoTResponse.dispatch_attached_policies,
     # The remaining routes can be handled by the default dispatcher.
     "{0}/.*$": IoTResponse.dispatch,
     #
     # (Flask) Paths for :class:`moto.core.models.ServerModeMockAWS`
     #
     # This route requires special handling.
-    "{0}/attached-policies/<path:target>$": IoTResponse.method_dispatch(
-        IoTResponse.dispatch_attached_policies
-    ),
+    "{0}/attached-policies/<path:target>$": IoTResponse.dispatch_attached_policies,
     # The remaining routes can be handled by the default dispatcher.
     "{0}/<path:route>$": IoTResponse.dispatch,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/pinpoint/responses.py

@@ -1,7 +1,6 @@
 """Handles incoming pinpoint requests, invokes methods, returns responses."""
 
 import json
-from typing import Any
 from urllib.parse import unquote
 
 from moto.core.common_types import TYPE_RESPONSE
@@ -21,21 +20,12 @@ class PinpointResponse(BaseResponse):
         """Return backend instance specific for this region."""
         return pinpoint_backends[self.current_account][self.region]
 
-    def tags(self, request: Any, full_url: str, headers: Any) -> TYPE_RESPONSE:  # type: ignore[return]
-        self.setup_class(request, full_url, headers)
-        if request.method == "DELETE":
-            return self.untag_resource()
-        if request.method == "GET":
-            return self.list_tags_for_resource()
-        if request.method == "POST":
-            return self.tag_resource()
-
     def create_app(self) -> TYPE_RESPONSE:
         params = json.loads(self.body)
         name = params.get("Name")
         tags = params.get("tags", {})
         app = self.pinpoint_backend.create_app(name=name, tags=tags)
-        return 201, {}, json.dumps(app.to_json())
+        return 201, {"status": 201}, json.dumps(app.to_json())
 
     def delete_app(self) -> str:
         application_id = self.path.split("/")[-1]
@@ -71,25 +61,25 @@ class PinpointResponse(BaseResponse):
         response["ApplicationId"] = application_id
         return json.dumps(response)
 
-    def list_tags_for_resource(self) -> TYPE_RESPONSE:
+    def list_tags_for_resource(self) -> str:
         resource_arn = unquote(self.path).split("/tags/")[-1]
         tags = self.pinpoint_backend.list_tags_for_resource(resource_arn=resource_arn)
-        return 200, {}, json.dumps(tags)
+        return json.dumps(tags)
 
-    def tag_resource(self) -> TYPE_RESPONSE:
+    def tag_resource(self) -> str:
         resource_arn = unquote(self.path).split("/tags/")[-1]
         tags = json.loads(self.body).get("tags", {})
         self.pinpoint_backend.tag_resource(resource_arn=resource_arn, tags=tags)
-        return 200, {}, "{}"
+        return "{}"
 
-    def untag_resource(self) -> TYPE_RESPONSE:
+    def untag_resource(self) -> str:
         resource_arn = unquote(self.path).split("/tags/")[-1]
         tag_keys = self.querystring.get("tagKeys")
         self.pinpoint_backend.untag_resource(
             resource_arn=resource_arn,
             tag_keys=tag_keys,  # type: ignore[arg-type]
         )
-        return 200, {}, "{}"
+        return "{}"
 
     def put_event_stream(self) -> str:
         application_id = self.path.split("/")[-2]

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/pinpoint/urls.py

@@ -12,10 +12,6 @@ url_paths = {
     "{0}/v1/apps/(?P<app_id>[^/]+)$": PinpointResponse.dispatch,
     "{0}/v1/apps/(?P<app_id>[^/]+)/eventstream": PinpointResponse.dispatch,
     "{0}/v1/apps/(?P<app_id>[^/]+)/settings$": PinpointResponse.dispatch,
-    "{0}/v1/tags/(?P<app_arn>[^/]+)$": PinpointResponse.method_dispatch(
-        PinpointResponse.tags
-    ),
-    "{0}/v1/tags/(?P<app_arn_pt_1>[^/]+)/(?P<app_arn_pt_2>[^/]+)$": PinpointResponse.method_dispatch(
-        PinpointResponse.tags
-    ),
+    "{0}/v1/tags/(?P<app_arn>[^/]+)$": PinpointResponse.dispatch,
+    "{0}/v1/tags/(?P<app_arn_pt_1>[^/]+)/(?P<app_arn_pt_2>[^/]+)$": PinpointResponse.dispatch,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/resiliencehub/responses.py

@@ -1,5 +1,4 @@
 import json
-from typing import Any
 from urllib.parse import unquote
 
 from moto.core.responses import BaseResponse
@@ -9,15 +8,6 @@ from .models import ResilienceHubBackend, resiliencehub_backends
 
 
 class ResilienceHubResponse(BaseResponse):
-    def tags(self, request: Any, full_url: str, headers: Any) -> str:  # type: ignore[return]
-        self.setup_class(request, full_url, headers)
-        if request.method == "GET":
-            return self.list_tags_for_resource()
-        if request.method == "POST":
-            return self.tag_resource()
-        if request.method == "DELETE":
-            return self.untag_resource()
-
     def __init__(self) -> None:
         super().__init__(service_name="resiliencehub")
 

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/resiliencehub/urls.py

@@ -22,8 +22,6 @@ url_paths = {
     "{0}/list-resiliency-policies$": ResilienceHubResponse.dispatch,
     "{0}/publish-app-version$": ResilienceHubResponse.dispatch,
     "{0}/tags/.+$": ResilienceHubResponse.dispatch,
-    "{0}/tags/(?P<arn_prefix>[^/]+)/(?P<workspace_id>[^/]+)$": ResilienceHubResponse.method_dispatch(
-        ResilienceHubResponse.tags  # type: ignore
-    ),
+    "{0}/tags/(?P<arn_prefix>[^/]+)/(?P<workspace_id>[^/]+)$": ResilienceHubResponse.dispatch,
     "{0}/.*$": ResilienceHubResponse.dispatch,
 }

{moto-5.0.14.dev5 → moto-5.0.14.dev7}/moto/s3/models.py

@@ -1047,7 +1047,7 @@ class FakeBucket(CloudFormationModel):
         self.versioning_status: Optional[str] = None
         self.rules: List[LifecycleRule] = []
         self.policy: Optional[bytes] = None
-        self.website_configuration: Optional[Dict[str, Any]] = None
+        self.website_configuration: Optional[bytes] = None
         self.acl: Optional[FakeAcl] = get_canned_acl("private")
         self.cors: List[CorsRule] = []
         self.logging: Dict[str, Any] = {}
@@ -1883,6 +1883,10 @@ class S3Backend(BaseBackend, CloudWatchMetricProvider):
             s3_backends.bucket_accounts.pop(bucket_name, None)
             return self.buckets.pop(bucket_name)
 
+    def get_bucket_accelerate_configuration(self, bucket_name: str) -> Optional[str]:
+        bucket = self.get_bucket(bucket_name)
+        return bucket.accelerate_configuration
+
     def put_bucket_versioning(self, bucket_name: str, status: str) -> None:
         self.get_bucket(bucket_name).versioning_status = status
 
@@ -2086,15 +2090,13 @@ class S3Backend(BaseBackend, CloudWatchMetricProvider):
         bucket = self.get_bucket(bucket_name)
         bucket.delete_lifecycle()
 
-    def set_bucket_website_configuration(
-        self, bucket_name: str, website_configuration: Dict[str, Any]
+    def put_bucket_website(
+        self, bucket_name: str, website_configuration: bytes
     ) -> None:
         bucket = self.get_bucket(bucket_name)
         bucket.website_configuration = website_configuration
 
-    def get_bucket_website_configuration(
-        self, bucket_name: str
-    ) -> Optional[Dict[str, Any]]:
+    def get_bucket_website_configuration(self, bucket_name: str) -> Optional[bytes]:
         bucket = self.get_bucket(bucket_name)
         return bucket.website_configuration
 
@@ -2558,7 +2560,10 @@ class S3Backend(BaseBackend, CloudWatchMetricProvider):
         )
         return key
 
-    def get_all_multiparts(self, bucket_name: str) -> Dict[str, FakeMultipart]:
+    def list_multipart_uploads(self, bucket_name: str) -> Dict[str, FakeMultipart]:
+        """
+        The delimiter and max-uploads parameters have not yet been implemented.
+        """
         bucket = self.get_bucket(bucket_name)
         return bucket.multiparts