


"""simple docstring"""







from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


__lowercase    					=      logging.get_logger(__name__)






class 						_A  (  _a  ):







    """simple docstring"""




    def __init__(					self				:    List[Any]				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    float				, **__UpperCAmelCase				:    Optional[int]):
      a						:		Optional[Any]      							=			feature_size
      a						:		Tuple      							=			sampling_rate
      a						:		Any      							=			padding_value

      a						:		Union[str, Any]      							=			kwargs.pop("padding_side"				, "right")
      a						:		List[str]      							=			kwargs.pop("return_attention_mask"				, __UpperCAmelCase)

      super().__init__(**__UpperCAmelCase)






    def 	__snake_case							(					self				:    Union[str, Any]				, __UpperCAmelCase				:    Union[
            BatchFeature,
            List[BatchFeature],
            Dict[str, BatchFeature],
            Dict[str, List[BatchFeature]],
            List[Dict[str, BatchFeature]],
        ]				, __UpperCAmelCase				:    Union[bool, str, PaddingStrategy] = True				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    bool = False				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    Optional[bool] = None				, __UpperCAmelCase				:    Optional[Union[str, TensorType]] = None				, ):
      # If we have a list of dicts, let's convert it in a dict of lists
      # We do this to allow using this method as a collate_fn function in PyTorch Dataloader
      if isinstance(__UpperCAmelCase				, (list, tuple)) and isinstance(processed_features[0]				, (dict, BatchFeature)):
        a						:		int      							=			{
            key: [example[key] for example in processed_features] for key in processed_features[0].keys()
        }

      # The model's main input name, usually `input_values`, has be passed for padding
      if self.model_input_names[0] not in processed_features:
        raise ValueError(
            "You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`"
            f''' to this method that includes {self.model_input_names[0]}, but you provided'''
            f''' {list(processed_features.keys())}''')

      a						:		Any      							=			processed_features[self.model_input_names[0]]
      a						:		Any      							=			(
          return_attention_mask if return_attention_mask is not None else self.return_attention_mask
      )

      if len(__UpperCAmelCase) == 0:
        if return_attention_mask:
          a						:		List[Any]      							=			[]
        return processed_features

      # If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
      # and rebuild them afterwards if no return_tensors is specified
      # Note that we lose the specific device the tensor may be on for PyTorch

      a						:		Tuple      							=			required_input[0]
      if isinstance(__UpperCAmelCase				, (list, tuple)):
        # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
        a						:		Union[str, Any]      							=			0
        while len(required_input[index]) == 0:
          index += 1
        if index < len(__UpperCAmelCase):
          a						:		Optional[Any]      							=			required_input[index][0]

      if return_tensors is None:
        if is_tf_tensor(__UpperCAmelCase):
          a						:		str      							=			"tf"
        elif is_torch_tensor(__UpperCAmelCase):
          a						:		Optional[Any]      							=			"pt"
        elif isinstance(__UpperCAmelCase				, (int, float, list, tuple, np.ndarray)):
          a						:		List[str]      							=			"np"
        else:
          raise ValueError(
              f'''type of {first_element} unknown: {type(__UpperCAmelCase)}. '''
              "Should be one of a python, numpy, pytorch or tensorflow object.")

      for key, value in processed_features.items():
        if isinstance(value[0]				, (int, float)):
          a						:		Any      							=			to_numpy(__UpperCAmelCase)
        else:
          a						:		int      							=			[to_numpy(__UpperCAmelCase) for v in value]

        # Convert padding_strategy in PaddingStrategy
      a						:		Any      							=			self._get_padding_strategies(padding=__UpperCAmelCase				, max_length=__UpperCAmelCase)

      a						:		int      							=			processed_features[self.model_input_names[0]]

      a						:		Union[str, Any]      							=			len(__UpperCAmelCase)
      if not all(len(__UpperCAmelCase) == batch_size for v in processed_features.values()):
        raise ValueError("Some items in the output dictionary have a different batch size than others.")

      a						:		Optional[int]      							=			[]
      for i in range(__UpperCAmelCase):
        a						:		Tuple      							=			{k: v[i] for k, v in processed_features.items()}
        # truncation
        a						:		List[str]      							=			self._truncate(
            __UpperCAmelCase				, max_length=__UpperCAmelCase				, pad_to_multiple_of=__UpperCAmelCase				, truncation=__UpperCAmelCase				, )
        truncated_inputs.append(__UpperCAmelCase)

      if padding_strategy == PaddingStrategy.LONGEST:
        # make sure that `max_length` cannot be longer than the longest truncated length
        a						:		Any      							=			max(len(input_slice[self.model_input_names[0]]) for input_slice in truncated_inputs)
        a						:		List[Any]      							=			PaddingStrategy.MAX_LENGTH

      a						:		Optional[Any]      							=			{}
      for i in range(__UpperCAmelCase):
        # padding
        a						:		Optional[Any]      							=			self._pad(
            truncated_inputs[i]				, max_length=__UpperCAmelCase				, padding_strategy=__UpperCAmelCase				, pad_to_multiple_of=__UpperCAmelCase				, return_attention_mask=__UpperCAmelCase				, )

        for key, value in outputs.items():
          if key not in batch_outputs:
            a						:		int      							=			[]
          if value.dtype is np.dtype(np.floataa):
            a						:		Any      							=			value.astype(np.floataa)
          batch_outputs[key].append(__UpperCAmelCase)

      return BatchFeature(__UpperCAmelCase				, tensor_type=__UpperCAmelCase)






    def 	__snake_case							(					self				:    List[str]				, __UpperCAmelCase				:    Union[Dict[str, np.ndarray], BatchFeature]				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    PaddingStrategy = PaddingStrategy.DO_NOT_PAD				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    Optional[bool] = None				, ):
      a						:		Tuple      							=			processed_features[self.model_input_names[0]]

      if padding_strategy == PaddingStrategy.LONGEST:
        a						:		List[Any]      							=			len(__UpperCAmelCase)

      if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
        a						:		Optional[int]      							=			((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

      a						:		Union[str, Any]      							=			padding_strategy != PaddingStrategy.DO_NOT_PAD and len(__UpperCAmelCase) < max_length

      if return_attention_mask and "attention_mask" not in processed_features:
        a						:		str      							=			np.ones(len(__UpperCAmelCase)				, dtype=np.intaa)

      if needs_to_be_padded:
        a						:		Dict      							=			max_length - len(__UpperCAmelCase)
        if self.padding_side == "right":
          if return_attention_mask:
            a						:		str      							=			np.pad(
                processed_features["attention_mask"]				, (0, difference))
          a						:		List[str]      							=			((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
          a						:		str      							=			np.pad(
              __UpperCAmelCase				, __UpperCAmelCase				, "constant"				, constant_values=self.padding_value)
        elif self.padding_side == "left":
          if return_attention_mask:
            a						:		List[str]      							=			np.pad(
                processed_features["attention_mask"]				, (difference, 0))
          a						:		Tuple      							=			((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
          a						:		int      							=			np.pad(
              __UpperCAmelCase				, __UpperCAmelCase				, "constant"				, constant_values=self.padding_value)
        else:
          raise ValueError("Invalid padding strategy:" + str(self.padding_side))

      return processed_features






    def 	__snake_case							(					self				:    List[str]				, __UpperCAmelCase				:    Union[Dict[str, np.ndarray], BatchFeature]				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    Optional[bool] = None				, ):
      if not truncation:
        return processed_features
      elif truncation and max_length is None:
        raise ValueError("When setting ``truncation=True``, make sure that ``max_length`` is defined.")

      a						:		str      							=			processed_features[self.model_input_names[0]]

      # find `max_length` that fits `pad_to_multiple_of`
      if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
        a						:		str      							=			((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

      a						:		Tuple      							=			len(__UpperCAmelCase) > max_length

      if needs_to_be_truncated:
        a						:		int      							=			processed_features[self.model_input_names[0]][:max_length]
        if "attention_mask" in processed_features:
          a						:		List[str]      							=			processed_features["attention_mask"][:max_length]

      return processed_features






    def 	__snake_case							(					self				:    Dict				, __UpperCAmelCase				:    Any=False				, __UpperCAmelCase				:    Optional[int]=None):

      # Get padding strategy
      if padding is not False:
        if padding is True:
          a						:		List[str]      							=			PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
        elif not isinstance(__UpperCAmelCase				, __UpperCAmelCase):
          a						:		Tuple      							=			PaddingStrategy(__UpperCAmelCase)
        elif isinstance(__UpperCAmelCase				, __UpperCAmelCase):
          a						:		str      							=			padding
      else:
        a						:		List[str]      							=			PaddingStrategy.DO_NOT_PAD

      # Set max length if needed
      if max_length is None:
        if padding_strategy == PaddingStrategy.MAX_LENGTH:
          raise ValueError(
              f'''When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined''')

        # Test if we have a padding value
      if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
        raise ValueError(
            "Asking to pad but the feature_extractor does not have a padding value. Please select a value to use"
            " as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.")

      return padding_strategy










"""simple docstring"""







from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowercase    					=      logging.get_logger(__name__)

__lowercase    					=      {
    """facebook/dpr-ctx_encoder-single-nq-base""": (
        """https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/config.json"""
    ),
    """facebook/dpr-question_encoder-single-nq-base""": (
        """https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/config.json"""
    ),
    """facebook/dpr-reader-single-nq-base""": (
        """https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/config.json"""
    ),
    """facebook/dpr-ctx_encoder-multiset-base""": (
        """https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/config.json"""
    ),
    """facebook/dpr-question_encoder-multiset-base""": (
        """https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/config.json"""
    ),
    """facebook/dpr-reader-multiset-base""": (
        """https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/config.json"""
    ),
}






class 						_A  (  _a  ):







    """simple docstring"""




    UpperCAmelCase       :							int	=       """dpr"""






    def __init__(					self				:    List[Any]				, __UpperCAmelCase				:    int=30522				, __UpperCAmelCase				:    Union[str, Any]=768				, __UpperCAmelCase				:    Dict=12				, __UpperCAmelCase				:    List[str]=12				, __UpperCAmelCase				:    Any=3072				, __UpperCAmelCase				:    Optional[int]="gelu"				, __UpperCAmelCase				:    Any=0.1				, __UpperCAmelCase				:    Union[str, Any]=0.1				, __UpperCAmelCase				:    str=512				, __UpperCAmelCase				:    List[str]=2				, __UpperCAmelCase				:    Tuple=0.02				, __UpperCAmelCase				:    List[str]=1e-12				, __UpperCAmelCase				:    List[str]=0				, __UpperCAmelCase				:    str="absolute"				, __UpperCAmelCase				:    int = 0				, **__UpperCAmelCase				:    Tuple				, ):
      super().__init__(pad_token_id=__UpperCAmelCase				, **__UpperCAmelCase)

      a						:		List[Any]      							=			vocab_size
      a						:		Optional[Any]      							=			hidden_size
      a						:		Union[str, Any]      							=			num_hidden_layers
      a						:		Dict      							=			num_attention_heads
      a						:		int      							=			hidden_act
      a						:		Any      							=			intermediate_size
      a						:		Any      							=			hidden_dropout_prob
      a						:		Dict      							=			attention_probs_dropout_prob
      a						:		Any      							=			max_position_embeddings
      a						:		Union[str, Any]      							=			type_vocab_size
      a						:		Optional[Any]      							=			initializer_range
      a						:		Dict      							=			layer_norm_eps
      a						:		int      							=			projection_dim
      a						:		str      							=			position_embedding_type






