

"""simple docstring"""


import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





class    snake_case     (    __snake_case,							unittest.TestCase  ):
				SCREAMING_SNAKE_CASE_       :				Tuple       				=  LDMTextToImagePipeline
				SCREAMING_SNAKE_CASE_       :				List[str]       				=  TEXT_TO_IMAGE_PARAMS - {
				    '''negative_prompt''',
				    '''negative_prompt_embeds''',
				    '''cross_attention_kwargs''',
				    '''prompt_embeds''',
				}
				SCREAMING_SNAKE_CASE_       :				Optional[int]       				=  PipelineTesterMixin.required_optional_params - {
				    '''num_images_per_prompt''',
				    '''callback''',
				    '''callback_steps''',
				}
				SCREAMING_SNAKE_CASE_       :				str       				=  TEXT_TO_IMAGE_BATCH_PARAMS
				SCREAMING_SNAKE_CASE_       :				List[str]       				=  False

				def 							lowercase_					(     self							:    Any)->       int:



						'''simple docstring'''


						torch.manual_seed(0)
						__lowerCAmelCase:	Any   				=      UNetaDConditionModel(
						    block_out_channels=(3_2, 6_4)					,  layers_per_block=2					,  sample_size=3_2					,  in_channels=4					,  out_channels=4					,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")					,  up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")					,  cross_attention_dim=3_2					,  )
						__lowerCAmelCase:	Any   				=      DDIMScheduler(
						    beta_start=0.00085					,  beta_end=0.012					,  beta_schedule="scaled_linear"					,  clip_sample=_a					,  set_alpha_to_one=_a					,  )
						torch.manual_seed(0)
						__lowerCAmelCase:	Dict   				=      AutoencoderKL(
						    block_out_channels=(3_2, 6_4)					,  in_channels=3					,  out_channels=3					,  down_block_types=("DownEncoderBlock2D", "DownEncoderBlock2D")					,  up_block_types=("UpDecoderBlock2D", "UpDecoderBlock2D")					,  latent_channels=4					,  )
						torch.manual_seed(0)
						__lowerCAmelCase:	Tuple   				=      CLIPTextConfig(
						    bos_token_id=0					,  eos_token_id=2					,  hidden_size=3_2					,  intermediate_size=3_7					,  layer_norm_eps=1e-05					,  num_attention_heads=4					,  num_hidden_layers=5					,  pad_token_id=1					,  vocab_size=1_0_0_0					,  )
						__lowerCAmelCase:	List[str]   				=      CLIPTextModel(_a)
						__lowerCAmelCase:	List[Any]   				=      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")

						__lowerCAmelCase:	List[str]   				=      {
						    "unet": unet,
						    "scheduler": scheduler,
						    "vqvae": vae,
						    "bert": text_encoder,
						    "tokenizer": tokenizer,
						}
						return components

				def 							lowercase_					(     self							:    List[Any]					,  UpperCamelCase__							:    str					,  UpperCamelCase__							:    Dict=0)->       str:



						'''simple docstring'''


						if str(_a).startswith("mps"):
								__lowerCAmelCase:	Any   				=      torch.manual_seed(_a)
						else:
								__lowerCAmelCase:	List[str]   				=      torch.Generator(device=_a).manual_seed(_a)
						__lowerCAmelCase:	int   				=      {
						    "prompt": "A painting of a squirrel eating a burger",
						    "generator": generator,
						    "num_inference_steps": 2,
						    "guidance_scale": 6.0,
						    "output_type": "numpy",
						}
						return inputs




				def 							lowercase_					(     self							:    str)->       List[Any]:



						'''simple docstring'''


						__lowerCAmelCase:	Optional[Any]   				=      "cpu"  # ensure determinism for the device-dependent torch.Generator

						__lowerCAmelCase:	List[Any]   				=      self.get_dummy_components()
						__lowerCAmelCase:	Optional[Any]   				=      LDMTextToImagePipeline(**_a)
						pipe.to(_a)
						pipe.set_progress_bar_config(disable=_a)

						__lowerCAmelCase:	Any   				=      self.get_dummy_inputs(_a)
						__lowerCAmelCase:	Optional[int]   				=      pipe(**_a).images
						__lowerCAmelCase:	Optional[Any]   				=      image[0, -3:, -3:, -1]

						assert image.shape == (1, 1_6, 1_6, 3)
						__lowerCAmelCase:	Optional[int]   				=      np.array([0.6101, 0.6156, 0.5622, 0.4895, 0.6661, 0.3804, 0.5748, 0.6136, 0.5014])

						assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-3





@slow
@require_torch_gpu
class    snake_case     (    unittest.TestCase  ):

				def 							lowercase_					(     self							:    Optional[int])->       Optional[int]:



						'''simple docstring'''


						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()

				def 							lowercase_					(     self							:    str					,  UpperCamelCase__							:    Optional[Any]					,  UpperCamelCase__							:    List[Any]=torch.floataa					,  UpperCamelCase__							:    Any=0)->       Optional[int]:



						'''simple docstring'''


						__lowerCAmelCase:	Optional[Any]   				=      torch.manual_seed(_a)
						__lowerCAmelCase:	List[str]   				=      np.random.RandomState(_a).standard_normal((1, 4, 3_2, 3_2))
						__lowerCAmelCase:	Optional[Any]   				=      torch.from_numpy(_a).to(device=_a					,  dtype=_a)
						__lowerCAmelCase:	str   				=      {
						    "prompt": "A painting of a squirrel eating a burger",
						    "latents": latents,
						    "generator": generator,
						    "num_inference_steps": 3,
						    "guidance_scale": 6.0,
						    "output_type": "numpy",
						}
						return inputs




				def 							lowercase_					(     self							:    Optional[Any])->       Optional[int]:



						'''simple docstring'''


						__lowerCAmelCase:	str   				=      LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256").to(_a)
						pipe.set_progress_bar_config(disable=_a)

						__lowerCAmelCase:	int   				=      self.get_inputs(_a)
						__lowerCAmelCase:	Dict   				=      pipe(**_a).images
						__lowerCAmelCase:	Union[str, Any]   				=      image[0, -3:, -3:, -1].flatten()

						assert image.shape == (1, 2_5_6, 2_5_6, 3)
						__lowerCAmelCase:	Tuple   				=      np.array([0.51825, 0.52850, 0.52543, 0.54258, 0.52304, 0.52569, 0.54363, 0.55276, 0.56878])
						__lowerCAmelCase:	List[str]   				=      np.abs(expected_slice - image_slice).max()
						assert max_diff < 1e-3





@nightly
@require_torch_gpu
class    snake_case     (    unittest.TestCase  ):

				def 							lowercase_					(     self							:    str)->       List[Any]:



						'''simple docstring'''


						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()

				def 							lowercase_					(     self							:    Optional[int]					,  UpperCamelCase__							:    Tuple					,  UpperCamelCase__							:    str=torch.floataa					,  UpperCamelCase__							:    Union[str, Any]=0)->       Dict:



						'''simple docstring'''


						__lowerCAmelCase:	Tuple   				=      torch.manual_seed(_a)
						__lowerCAmelCase:	Dict   				=      np.random.RandomState(_a).standard_normal((1, 4, 3_2, 3_2))
						__lowerCAmelCase:	int   				=      torch.from_numpy(_a).to(device=_a					,  dtype=_a)
						__lowerCAmelCase:	Any   				=      {
						    "prompt": "A painting of a squirrel eating a burger",
						    "latents": latents,
						    "generator": generator,
						    "num_inference_steps": 5_0,
						    "guidance_scale": 6.0,
						    "output_type": "numpy",
						}
						return inputs




				def 							lowercase_					(     self							:    Optional[int])->       Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:	Any   				=      LDMTextToImagePipeline.from_pretrained("CompVis/ldm-text2im-large-256").to(_a)
						pipe.set_progress_bar_config(disable=_a)

						__lowerCAmelCase:	Tuple   				=      self.get_inputs(_a)
						__lowerCAmelCase:	Dict   				=      pipe(**_a).images[0]

						__lowerCAmelCase:	Optional[Any]   				=      load_numpy(
						    "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy")
						__lowerCAmelCase:	Dict   				=      np.abs(expected_image - image).max()
						assert max_diff < 1e-3





"""simple docstring"""


import collections
from typing import List, Optional, Union

from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging
from ..bert.tokenization_bert_fast import BertTokenizerFast
from .tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer, DPRReaderTokenizer


__A						       =      logging.get_logger(__name__)

__A						       =      {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

__A						       =      {
    "vocab_file": {
        "facebook/dpr-ctx_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt"
        ),
        "facebook/dpr-ctx_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "facebook/dpr-ctx_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json"
        ),
        "facebook/dpr-ctx_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json"
        ),
    },
}
__A						       =      {
    "vocab_file": {
        "facebook/dpr-question_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt"
        ),
        "facebook/dpr-question_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "facebook/dpr-question_encoder-single-nq-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json"
        ),
        "facebook/dpr-question_encoder-multiset-base": (
            "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json"
        ),
    },
}
__A						       =      {
    "vocab_file": {
        "facebook/dpr-reader-single-nq-base": (
            "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt"
        ),
        "facebook/dpr-reader-multiset-base": (
            "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "facebook/dpr-reader-single-nq-base": (
            "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json"
        ),
        "facebook/dpr-reader-multiset-base": (
            "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json"
        ),
    },
}

__A						       =      {
    "facebook/dpr-ctx_encoder-single-nq-base": 512,
    "facebook/dpr-ctx_encoder-multiset-base": 512,
}
__A						       =      {
    "facebook/dpr-question_encoder-single-nq-base": 512,
    "facebook/dpr-question_encoder-multiset-base": 512,
}
__A						       =      {
    "facebook/dpr-reader-single-nq-base": 512,
    "facebook/dpr-reader-multiset-base": 512,
}


__A						       =      {
    "facebook/dpr-ctx_encoder-single-nq-base": {"do_lower_case": True},
    "facebook/dpr-ctx_encoder-multiset-base": {"do_lower_case": True},
}
__A						       =      {
    "facebook/dpr-question_encoder-single-nq-base": {"do_lower_case": True},
    "facebook/dpr-question_encoder-multiset-base": {"do_lower_case": True},
}
__A						       =      {
    "facebook/dpr-reader-single-nq-base": {"do_lower_case": True},
    "facebook/dpr-reader-multiset-base": {"do_lower_case": True},
}





class    snake_case     (    __snake_case  ):
				SCREAMING_SNAKE_CASE_       :				List[Any]       				=  VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_       :				List[Any]       				=  CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_       :				Any       				=  CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_       :				int       				=  CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION
				SCREAMING_SNAKE_CASE_       :				Union[str, Any]       				=  DPRContextEncoderTokenizer





class    snake_case     (    __snake_case  ):
				SCREAMING_SNAKE_CASE_       :				Union[str, Any]       				=  VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_       :				List[str]       				=  QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_       :				Optional[Any]       				=  QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_       :				Optional[int]       				=  QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION
				SCREAMING_SNAKE_CASE_       :				Tuple       				=  DPRQuestionEncoderTokenizer


__A						       =      collections.namedtuple(
    "DPRSpanPrediction", ["span_score", "relevance_score", "doc_id", "start_index", "end_index", "text"]
)

__A						       =      collections.namedtuple("DPRReaderOutput", ["start_logits", "end_logits", "relevance_logits"])


__A						       =      r"\n    Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n    It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n    using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n    with the format:\n\n    [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n\n    Args:\n        questions (`str` or `List[str]`):\n            The questions to be encoded. You can specify one question for many passages. In this case, the question\n            will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n            `titles` or `texts`.\n        titles (`str` or `List[str]`):\n            The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n        texts (`str` or `List[str]`):\n            The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n        padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n            Activates and controls padding. Accepts the following values:\n\n            - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n              if provided).\n            - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided.\n            - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different\n              lengths).\n        truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n            Activates and controls truncation. Accepts the following values:\n\n            - `True` or `'longest_first'`: Truncate to a maximum length specified with the argument `max_length` or to\n              the maximum acceptable input length for the model if that argument is not provided. This will truncate\n              token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n              of pairs) is provided.\n            - `'only_first'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the first\n              sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `'only_second'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the\n              second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `False` or `'do_not_truncate'` (default): No truncation (i.e., can output batch with sequence lengths\n              greater than the model maximum admissible input size).\n        max_length (`int`, *optional*):\n                Controls the maximum length to use by one of the truncation/padding parameters.\n\n                If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n                is required by one of the truncation/padding parameters. If the model has no specific maximum input\n                length (like XLNet) truncation/padding to a maximum length will be deactivated.\n        return_tensors (`str` or [`~utils.TensorType`], *optional*):\n                If set, will return tensors instead of list of python integers. Acceptable values are:\n\n                - `'tf'`: Return TensorFlow `tf.constant` objects.\n                - `'pt'`: Return PyTorch `torch.Tensor` objects.\n                - `'np'`: Return Numpy `np.ndarray` objects.\n        return_attention_mask (`bool`, *optional*):\n            Whether or not to return the attention mask. If not set, will return the attention mask according to the\n            specific tokenizer's default, defined by the `return_outputs` attribute.\n\n            [What are attention masks?](../glossary#attention-mask)\n\n    Return:\n        `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n        - `input_ids`: List of token ids to be fed to a model.\n        - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n    "





@add_start_docstrings(__snake_case  )
class    snake_case     :

				def __call__(     self							:    int					,  UpperCamelCase__							:    Optional[Any]					,  UpperCamelCase__							:    Optional[str] = None					,  UpperCamelCase__							:    Optional[str] = None					,  UpperCamelCase__							:    Union[bool, str] = False					,  UpperCamelCase__							:    Union[bool, str] = False					,  UpperCamelCase__							:    Optional[int] = None					,  UpperCamelCase__							:    Optional[Union[str, TensorType]] = None					,  UpperCamelCase__							:    Optional[bool] = None					,  **UpperCamelCase__							:    Dict					,  )->       BatchEncoding:



						'''simple docstring'''


						if titles is None and texts is None:
								return super().__call__(
								    UpperCamelCase__					,  padding=UpperCamelCase__					,  truncation=UpperCamelCase__					,  max_length=UpperCamelCase__					,  return_tensors=UpperCamelCase__					,  return_attention_mask=UpperCamelCase__					,  **UpperCamelCase__					,  )
						elif titles is None or texts is None:
								__lowerCAmelCase:	Tuple   				=      titles if texts is None else texts
								return super().__call__(
								    UpperCamelCase__					,  UpperCamelCase__					,  padding=UpperCamelCase__					,  truncation=UpperCamelCase__					,  max_length=UpperCamelCase__					,  return_tensors=UpperCamelCase__					,  return_attention_mask=UpperCamelCase__					,  **UpperCamelCase__					,  )
						__lowerCAmelCase:	Dict   				=      titles if not isinstance(UpperCamelCase__					,  UpperCamelCase__) else [titles]
						__lowerCAmelCase:	Optional[Any]   				=      texts if not isinstance(UpperCamelCase__					,  UpperCamelCase__) else [texts]
						__lowerCAmelCase:	Union[str, Any]   				=      len(UpperCamelCase__)
						__lowerCAmelCase:	List[str]   				=      questions if not isinstance(UpperCamelCase__					,  UpperCamelCase__) else [questions] * n_passages
						assert len(UpperCamelCase__) == len(
						    UpperCamelCase__), f"There should be as many titles than texts but got {len(UpperCamelCase__)} titles and {len(UpperCamelCase__)} texts."
						__lowerCAmelCase:	Tuple   				=      super().__call__(UpperCamelCase__					,  UpperCamelCase__					,  padding=UpperCamelCase__					,  truncation=UpperCamelCase__)["input_ids"]
						__lowerCAmelCase:	Union[str, Any]   				=      super().__call__(UpperCamelCase__					,  add_special_tokens=UpperCamelCase__					,  padding=UpperCamelCase__					,  truncation=UpperCamelCase__)["input_ids"]
						__lowerCAmelCase:	Optional[int]   				=      {
						    "input_ids": [
						        (encoded_question_and_title + encoded_text)[:max_length]
						        if max_length is not None and truncation
						        else encoded_question_and_title + encoded_text
						        for encoded_question_and_title, encoded_text in zip(UpperCamelCase__					,  UpperCamelCase__)
						    ]
						}
						if return_attention_mask is not False:
								__lowerCAmelCase:	Tuple   				=      []
								for input_ids in encoded_inputs["input_ids"]:
										attention_mask.append([int(input_id != self.pad_token_id) for input_id in input_ids])
								__lowerCAmelCase:	List[Any]   				=      attention_mask
						return self.pad(UpperCamelCase__					,  padding=UpperCamelCase__					,  max_length=UpperCamelCase__					,  return_tensors=UpperCamelCase__)

				def 							lowercase_					(     self							:    List[Any]					,  UpperCamelCase__							:    BatchEncoding					,  UpperCamelCase__							:    DPRReaderOutput					,  UpperCamelCase__							:    int = 1_6					,  UpperCamelCase__							:    int = 6_4					,  UpperCamelCase__							:    int = 4					,  )->       List[DPRSpanPrediction]:



						'''simple docstring'''


						__lowerCAmelCase:	List[Any]   				=      reader_input["input_ids"]
						__lowerCAmelCase				,			__lowerCAmelCase				,			__lowerCAmelCase:	List[Any]   				=      reader_output[:3]
						__lowerCAmelCase:	Optional[int]   				=      len(UpperCamelCase__)
						__lowerCAmelCase:	Union[str, Any]   				=      sorted(range(UpperCamelCase__)					,  reverse=UpperCamelCase__					,  key=relevance_logits.__getitem__)
						__lowerCAmelCase:	List[DPRReaderOutput]   				=      []
						for doc_id in sorted_docs:
								__lowerCAmelCase:	Any   				=      list(input_ids[doc_id])
								# assuming question & title information is at the beginning of the sequence
								__lowerCAmelCase:	Dict   				=      sequence_ids.index(self.sep_token_id					,  2) + 1  # second sep id
								if sequence_ids[-1] == self.pad_token_id:
										__lowerCAmelCase:	str   				=      sequence_ids.index(self.pad_token_id)
								else:
										__lowerCAmelCase:	Union[str, Any]   				=      len(UpperCamelCase__)

								__lowerCAmelCase:	Tuple   				=      self._get_best_spans(
								    start_logits=start_logits[doc_id][passage_offset:sequence_len]					,  end_logits=end_logits[doc_id][passage_offset:sequence_len]					,  max_answer_length=UpperCamelCase__					,  top_spans=UpperCamelCase__					,  )
								for start_index, end_index in best_spans:
										start_index += passage_offset
										end_index += passage_offset
										nbest_spans_predictions.append(
										    DPRSpanPrediction(
										        span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index]					,  relevance_score=relevance_logits[doc_id]					,  doc_id=UpperCamelCase__					,  start_index=UpperCamelCase__					,  end_index=UpperCamelCase__					,  text=self.decode(sequence_ids[start_index : end_index + 1])					,  ))
								if len(UpperCamelCase__) >= num_spans:
										break
						return nbest_spans_predictions[:num_spans]




				def 							lowercase_					(     self							:    int					,  UpperCamelCase__							:    List[int]					,  UpperCamelCase__							:    List[int]					,  UpperCamelCase__							:    int					,  UpperCamelCase__							:    int					,  )->       List[DPRSpanPrediction]:



						'''simple docstring'''


						__lowerCAmelCase:	Tuple   				=      []
						for start_index, start_score in enumerate(UpperCamelCase__):
								for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]):
										scores.append(((start_index, start_index + answer_length), start_score + end_score))
						__lowerCAmelCase:	Tuple   				=      sorted(UpperCamelCase__					,  key=lambda UpperCamelCase__: x[1]					,  reverse=UpperCamelCase__)
						__lowerCAmelCase:	Tuple   				=      []
						for (start_index, end_index), score in scores:
								assert start_index <= end_index, f"Wrong span indices: [{start_index}:{end_index}]"
								__lowerCAmelCase:	Any   				=      end_index - start_index + 1
								assert length <= max_answer_length, f"Span is too long: {length} > {max_answer_length}"
								if any(
								    start_index <= prev_start_index <= prev_end_index <= end_index
								    or prev_start_index <= start_index <= end_index <= prev_end_index
								    for (prev_start_index, prev_end_index) in chosen_span_intervals):
										continue
								chosen_span_intervals.append((start_index, end_index))

								if len(UpperCamelCase__) == top_spans:
										break
						return chosen_span_intervals





@add_end_docstrings(__snake_case  )
class    snake_case     (    __snake_case,							__snake_case  ):
				SCREAMING_SNAKE_CASE_       :				Union[str, Any]       				=  VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_       :				str       				=  READER_PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_       :				List[str]       				=  READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_       :				int       				=  READER_PRETRAINED_INIT_CONFIGURATION
				SCREAMING_SNAKE_CASE_       :				Optional[Any]       				=  ["""input_ids""", """attention_mask"""]
				SCREAMING_SNAKE_CASE_       :				Optional[int]       				=  DPRReaderTokenizer


