def describe_network_interfaces(self):
     eni_ids = sequence_from_querystring(
         'NetworkInterfaceId', self.querystring)
     filters = filters_from_querystring(self.querystring)
     enis = self.ec2_backend.get_all_network_interfaces(eni_ids, filters)
     template = self.response_template(DESCRIBE_NETWORK_INTERFACES_RESPONSE)
     return template.render(enis=enis)

 def describe_dhcp_options(self):
     dhcp_opt_ids = dhcp_opt_ids_from_querystring(self.querystring)
     if filters_from_querystring(self.querystring):
         raise NotImplementedError("Filtering not supported in describe_dhcp_options.")
     dhcp_opts = self.ec2_backend.get_all_dhcp_options(dhcp_opt_ids, None)
     template = self.response_template(DESCRIBE_DHCP_OPTIONS_RESPONSE)
     return template.render(dhcp_options=dhcp_opts)

 def describe_images(self):
     ami_ids = image_ids_from_querystring(self.querystring)
     filters = filters_from_querystring(self.querystring)
     images = self.ec2_backend.describe_images(
         ami_ids=ami_ids, filters=filters)
     template = self.response_template(DESCRIBE_IMAGES_RESPONSE)
     return template.render(images=images)

 def describe_route_tables(self):
     route_table_ids = route_table_ids_from_querystring(self.querystring)
     filters = filters_from_querystring(self.querystring)
     route_tables = self.ec2_backend.get_all_route_tables(
         route_table_ids, filters)
     template = self.response_template(DESCRIBE_ROUTE_TABLES_RESPONSE)
     return template.render(route_tables=route_tables)

 def describe_vpn_connections(self):
     vpn_connection_ids = sequence_from_querystring('VpnConnectionId', self.querystring)
     filters = filters_from_querystring(self.querystring)
     vpn_connections = self.ec2_backend.get_all_vpn_connections(
         vpn_connection_ids=vpn_connection_ids, filters=filters)
     template = self.response_template(DESCRIBE_VPN_CONNECTION_RESPONSE)
     return template.render(vpn_connections=vpn_connections)

 def describe_dhcp_options(self):
     dhcp_opt_ids = self._get_multi_param("DhcpOptionsId")
     filters = filters_from_querystring(self.querystring)
     dhcp_opts = self.ec2_backend.get_all_dhcp_options(
         dhcp_opt_ids, filters)
     template = self.response_template(DESCRIBE_DHCP_OPTIONS_RESPONSE)
     return template.render(dhcp_options=dhcp_opts)

 def describe_vpcs(self):
     vpc_ids = self._get_multi_param('VpcId')
     filters = filters_from_querystring(self.querystring)
     vpcs = self.ec2_backend.get_all_vpcs(vpc_ids=vpc_ids, filters=filters)
     doc_date = '2013-10-15' if 'Boto/' in self.headers.get('user-agent', '') else '2016-11-15'
     template = self.response_template(DESCRIBE_VPCS_RESPONSE)
     return template.render(vpcs=vpcs, doc_date=doc_date)

 def describe_network_acls(self):
     network_acl_ids = network_acl_ids_from_querystring(self.querystring)
     filters = filters_from_querystring(self.querystring)
     network_acls = self.ec2_backend.get_all_network_acls(
         network_acl_ids, filters)
     template = self.response_template(DESCRIBE_NETWORK_ACL_RESPONSE)
     return template.render(network_acls=network_acls)

 def describe_tags(self):
     filters = filters_from_querystring(querystring_dict=self.querystring)
     tags = self.ec2_backend.describe_tags(filters=filters)
     for tag in tags:
         tag['value'] = escape(tag['value'])
     template = self.response_template(DESCRIBE_RESPONSE)
     return template.render(tags=tags)

 def describe_addresses(self):
     allocation_ids = self._get_multi_param('AllocationId')
     public_ips = self._get_multi_param('PublicIp')
     filters = filters_from_querystring(self.querystring)
     addresses = self.ec2_backend.describe_addresses(
         allocation_ids, public_ips, filters)
     template = self.response_template(DESCRIBE_ADDRESS_RESPONSE)
     return template.render(addresses=addresses)

 def describe_images(self):
     ami_ids = self._get_multi_param('ImageId')
     filters = filters_from_querystring(self.querystring)
     exec_users = self._get_multi_param('ExecutableBy')
     images = self.ec2_backend.describe_images(
         ami_ids=ami_ids, filters=filters, exec_users=exec_users)
     template = self.response_template(DESCRIBE_IMAGES_RESPONSE)
     return template.render(images=images)

 def describe_volumes(self):
     filters = filters_from_querystring(self.querystring)
     # querystring for multiple volumeids results in VolumeId.1, VolumeId.2 etc
     volume_ids = ','.join([','.join(v[1]) for v in self.querystring.items() if 'VolumeId' in v[0]])
     volumes = self.ec2_backend.describe_volumes(filters=filters)
     # Describe volumes to handle filter on volume_ids
     volumes = [v for v in volumes if v.id in volume_ids] if volume_ids else volumes
     template = self.response_template(DESCRIBE_VOLUMES_RESPONSE)
     return template.render(volumes=volumes)

    def describe_key_pairs(self):
        names = keypair_names_from_querystring(self.querystring)
        filters = filters_from_querystring(self.querystring)
        if len(filters) > 0:
            raise NotImplementedError('Using filters in KeyPairs.describe_key_pairs is not yet implemented')

        keypairs = self.ec2_backend.describe_key_pairs(names)
        template = self.response_template(DESCRIBE_KEY_PAIRS_RESPONSE)
        return template.render(keypairs=keypairs)

 def describe_snapshots(self):
     filters = filters_from_querystring(self.querystring)
     # querystring for multiple snapshotids results in SnapshotId.1, SnapshotId.2 etc
     snapshot_ids = ','.join([','.join(s[1]) for s in self.querystring.items() if 'SnapshotId' in s[0]])
     snapshots = self.ec2_backend.describe_snapshots(filters=filters)
     # Describe snapshots to handle filter on snapshot_ids
     snapshots = [s for s in snapshots if s.id in snapshot_ids] if snapshot_ids else snapshots
     template = self.response_template(DESCRIBE_SNAPSHOTS_RESPONSE)
     return template.render(snapshots=snapshots)

    def describe_security_groups(self):
        groupnames = self._get_multi_param("GroupName")
        group_ids = self._get_multi_param("GroupId")
        filters = filters_from_querystring(self.querystring)

        groups = self.ec2_backend.describe_security_groups(group_ids=group_ids, groupnames=groupnames, filters=filters)

        template = self.response_template(DESCRIBE_SECURITY_GROUPS_RESPONSE)
        return template.render(groups=groups)

    def describe_instances(self):
        filter_dict = filters_from_querystring(self.querystring)
        instance_ids = instance_ids_from_querystring(self.querystring)
        if instance_ids:
            reservations = self.ec2_backend.get_reservations_by_instance_ids(instance_ids, filters=filter_dict)
        else:
            reservations = self.ec2_backend.all_reservations(make_copy=True, filters=filter_dict)

        template = self.response_template(EC2_DESCRIBE_INSTANCES)
        return template.render(reservations=reservations)

    def describe_internet_gateways(self):
        filter_dict = filters_from_querystring(self.querystring)
        if "InternetGatewayId.1" in self.querystring:
            igw_ids = sequence_from_querystring(
                "InternetGatewayId", self.querystring)
            igws = self.ec2_backend.describe_internet_gateways(igw_ids, filters=filter_dict)
        else:
            igws = self.ec2_backend.describe_internet_gateways(filters=filter_dict)

        template = Template(DESCRIBE_INTERNET_GATEWAYS_RESPONSE)
        return template.render(internet_gateways=igws)

 def describe_network_interfaces(self):
     # Partially implemented. Supports only network-interface-id and group-id filters
     filters = filters_from_querystring(self.querystring)
     eni_ids = self._get_multi_param("NetworkInterfaceId.")
     if "network-interface-id" not in filters and eni_ids:
         # Network interfaces can be filtered by passing the 'network-interface-id'
         # filter or by passing the NetworkInterfaceId parameter
         filters["network-interface-id"] = eni_ids
     enis = self.ec2_backend.describe_network_interfaces(filters)
     template = self.response_template(DESCRIBE_NETWORK_INTERFACES_RESPONSE)
     return template.render(enis=enis)

    def describe_security_groups(self):
        groupnames = process_groupnames_from_querystring(self.querystring)
        group_ids = process_group_ids_from_querystring(self.querystring)
        filters = filters_from_querystring(self.querystring)

        groups = ec2_backend.describe_security_groups(
            group_ids=group_ids,
            groupnames=groupnames,
            filters=filters
        )

        template = Template(DESCRIBE_SECURITY_GROUPS_RESPONSE)
        return template.render(groups=groups)

    def describe_key_pairs(self):
        names = keypair_names_from_querystring(self.querystring)
        filters = filters_from_querystring(self.querystring)
        if len(filters) > 0:
            raise NotImplementedError('Using filters in KeyPairs.describe_key_pairs is not yet implemented')

        try:
            keypairs = ec2_backend.describe_key_pairs(names)
        except InvalidIdError as exc:
            template = Template(CREATE_KEY_PAIR_NOT_FOUND)
            return template.render(keypair_id=exc.id), dict(status=400)
        else:
            template = Template(DESCRIBE_KEY_PAIRS_RESPONSE)
            return template.render(keypairs=keypairs)