How to use the moto.core.responses.BaseResponse function in moto

from __future__ import unicode_literals
from moto.core.responses import BaseResponse
from moto.ec2.utils import filters_from_querystring


class ElasticBlockStore(BaseResponse):
    def attach_volume(self):
        volume_id = self._get_param("VolumeId")
        instance_id = self._get_param("InstanceId")
        device_path = self._get_param("Device")
        if self.is_not_dryrun("AttachVolume"):
            attachment = self.ec2_backend.attach_volume(
                volume_id, instance_id, device_path
            )
            template = self.response_template(ATTACHED_VOLUME_RESPONSE)
            return template.render(attachment=attachment)

    def copy_snapshot(self):
        source_snapshot_id = self._get_param("SourceSnapshotId")
        source_region = self._get_param("SourceRegion")
        description = self._get_param("Description")
        if self.is_not_dryrun("CopySnapshot"):

from moto.core.utils import amz_crc32, amzn_request_id
from .utils import parse_message_attributes
from .models import sqs_backends
from .exceptions import (
    MessageAttributesInvalid,
    MessageNotInflight,
    QueueDoesNotExist,
    ReceiptHandleIsInvalid,
)

MAXIMUM_VISIBILTY_TIMEOUT = 43200
MAXIMUM_MESSAGE_LENGTH = 262144  # 256 KiB
DEFAULT_RECEIVED_MESSAGES = 1


class SQSResponse(BaseResponse):

    region_regex = re.compile(r"://(.+?)\.queue\.amazonaws\.com")

    @property
    def sqs_backend(self):
        return sqs_backends[self.region]

    @property
    def attribute(self):
        if not hasattr(self, "_attribute"):
            self._attribute = self._get_map_prefix(
                "Attribute", key_end=".Name", value_end=".Value"
            )
        return self._attribute

    def _get_queue_name(self):

from __future__ import unicode_literals
import json
from base64 import b64encode
from datetime import datetime
import time

from moto.core.responses import BaseResponse
from .models import ecr_backends, DEFAULT_REGISTRY_ID


class ECRResponse(BaseResponse):
    @property
    def ecr_backend(self):
        return ecr_backends[self.region]

    @property
    def request_params(self):
        try:
            return json.loads(self.body)
        except ValueError:
            return {}

    def _get_param(self, param):
        return self.request_params.get(param, None)

    def create_repository(self):
        repository_name = self._get_param("repositoryName")

from __future__ import unicode_literals
from moto.core.responses import BaseResponse


class VMImport(BaseResponse):
    def cancel_conversion_task(self):
        raise NotImplementedError(
            "VMImport.cancel_conversion_task is not yet implemented"
        )

    def describe_conversion_tasks(self):
        raise NotImplementedError(
            "VMImport.describe_conversion_tasks is not yet implemented"
        )

    def import_instance(self):
        raise NotImplementedError("VMImport.import_instance is not yet implemented")

    def import_volume(self):
        raise NotImplementedError("VMImport.import_volume is not yet implemented")

from moto.core.responses import BaseResponse
from .models import logs_backends
import json


# See http://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/Welcome.html


class LogsResponse(BaseResponse):
    @property
    def logs_backend(self):
        return logs_backends[self.region]

    @property
    def request_params(self):
        try:
            return json.loads(self.body)
        except ValueError:
            return {}

    def _get_param(self, param, if_none=None):
        return self.request_params.get(param, if_none)

    def create_log_group(self):
        log_group_name = self._get_param("logGroupName")

from __future__ import unicode_literals
from moto.core.responses import BaseResponse
from moto.ec2.utils import filters_from_querystring


class VirtualPrivateGateways(BaseResponse):
    def attach_vpn_gateway(self):
        vpn_gateway_id = self._get_param("VpnGatewayId")
        vpc_id = self._get_param("VpcId")
        attachment = self.ec2_backend.attach_vpn_gateway(vpn_gateway_id, vpc_id)
        template = self.response_template(ATTACH_VPN_GATEWAY_RESPONSE)
        return template.render(attachment=attachment)

    def create_vpn_gateway(self):
        type = self._get_param("Type")
        vpn_gateway = self.ec2_backend.create_vpn_gateway(type)
        template = self.response_template(CREATE_VPN_GATEWAY_RESPONSE)
        return template.render(vpn_gateway=vpn_gateway)

    def delete_vpn_gateway(self):
        vpn_gateway_id = self._get_param("VpnGatewayId")
        vpn_gateway = self.ec2_backend.delete_vpn_gateway(vpn_gateway_id)

from __future__ import unicode_literals
import json

try:
    from urllib import unquote
except ImportError:
    from urllib.parse import unquote

from moto.core.responses import BaseResponse
from .models import resourcegroups_backends


class ResourceGroupsResponse(BaseResponse):
    SERVICE_NAME = "resource-groups"

    @property
    def resourcegroups_backend(self):
        return resourcegroups_backends[self.region]

    def create_group(self):
        name = self._get_param("Name")
        description = self._get_param("Description")
        resource_query = self._get_param("ResourceQuery")
        tags = self._get_param("Tags")
        group = self.resourcegroups_backend.create_group(
            name=name, description=description, resource_query=resource_query, tags=tags
        )
        return json.dumps(
            {

from __future__ import unicode_literals

from moto.core.responses import BaseResponse
from moto.ec2.models import validate_resource_ids
from moto.ec2.utils import tags_from_query_string, filters_from_querystring


class TagResponse(BaseResponse):
    def create_tags(self):
        resource_ids = self._get_multi_param("ResourceId")
        validate_resource_ids(resource_ids)
        self.ec2_backend.do_resources_exist(resource_ids)
        tags = tags_from_query_string(self.querystring)
        if self.is_not_dryrun("CreateTags"):
            self.ec2_backend.create_tags(resource_ids, tags)
            return CREATE_RESPONSE

    def delete_tags(self):
        resource_ids = self._get_multi_param("ResourceId")
        validate_resource_ids(resource_ids)
        tags = tags_from_query_string(self.querystring)
        if self.is_not_dryrun("DeleteTags"):
            self.ec2_backend.delete_tags(resource_ids, tags)
            return DELETE_RESPONSE

{"name": "ECDHE-RSA-AES256-SHA384", "priority": 10},
            {"name": "ECDHE-RSA-AES256-SHA", "priority": 11},
            {"name": "ECDHE-ECDSA-AES256-SHA", "priority": 12},
            {"name": "AES128-GCM-SHA256", "priority": 13},
            {"name": "AES128-SHA256", "priority": 14},
            {"name": "AES128-SHA", "priority": 15},
            {"name": "AES256-GCM-SHA384", "priority": 16},
            {"name": "AES256-SHA256", "priority": 17},
            {"name": "AES256-SHA", "priority": 18},
            {"name": "DES-CBC3-SHA", "priority": 19},
        ],
    },
]


class ELBV2Response(BaseResponse):
    @property
    def elbv2_backend(self):
        return elbv2_backends[self.region]

    @amzn_request_id
    def create_load_balancer(self):
        load_balancer_name = self._get_param("Name")
        subnet_ids = self._get_multi_param("Subnets.member")
        security_groups = self._get_multi_param("SecurityGroups.member")
        scheme = self._get_param("Scheme")

        load_balancer = self.elbv2_backend.create_load_balancer(
            name=load_balancer_name,
            security_groups=security_groups,
            subnet_ids=subnet_ids,
            scheme=scheme,

from __future__ import unicode_literals
from moto.core.responses import BaseResponse
from moto.ec2.utils import filters_from_querystring


class ElasticNetworkInterfaces(BaseResponse):
    def create_network_interface(self):
        subnet_id = self._get_param("SubnetId")
        private_ip_address = self._get_param("PrivateIpAddress")
        private_ip_addresses = self._get_multi_param("PrivateIpAddresses")
        groups = self._get_multi_param("SecurityGroupId")
        subnet = self.ec2_backend.get_subnet(subnet_id)
        description = self._get_param("Description")
        if self.is_not_dryrun("CreateNetworkInterface"):
            eni = self.ec2_backend.create_network_interface(
                subnet, private_ip_address, private_ip_addresses, groups, description
            )
            template = self.response_template(CREATE_NETWORK_INTERFACE_RESPONSE)
            return template.render(eni=eni)

    def delete_network_interface(self):
        eni_id = self._get_param("NetworkInterfaceId")