





'''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


__UpperCAmelCase            =       logging.get_logger(__name__)




class      UpperCamelCase__					(					lowercase_			):




					"""simple docstring"""


					def __init__(						self				:			Tuple      ,						lowerCamelCase_				:			int      ,						lowerCamelCase_				:			int      ,						lowerCamelCase_				:			float      ,						**lowerCamelCase_				:			List[str]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[int]		=			feature_size
							SCREAMING_SNAKE_CASE :				Any		=			sampling_rate
							SCREAMING_SNAKE_CASE :				Dict		=			padding_value

							SCREAMING_SNAKE_CASE :				int		=			kwargs.pop("""padding_side"""      ,						"""right"""						)
							SCREAMING_SNAKE_CASE :				str		=			kwargs.pop("""return_attention_mask"""      ,						lowerCamelCase_						)

							super().__init__(**lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			List[str]      ,						lowerCamelCase_				:			Union[
					        BatchFeature,
					        List[BatchFeature],
					        Dict[str, BatchFeature],
					        Dict[str, List[BatchFeature]],
					        List[Dict[str, BatchFeature]],
					    ]      ,						lowerCamelCase_				:			Union[bool, str, PaddingStrategy] = True      ,						lowerCamelCase_				:			Optional[int] = None      ,						lowerCamelCase_				:			bool = False      ,						lowerCamelCase_				:			Optional[int] = None      ,						lowerCamelCase_				:			Optional[bool] = None      ,						lowerCamelCase_				:			Optional[Union[str, TensorType]] = None      ,						):

							'''simple docstring'''



							if isinstance(lowerCamelCase_      ,						(list, tuple)						) and isinstance(processed_features[0]      ,						(dict, BatchFeature)						):
									SCREAMING_SNAKE_CASE :				List[Any]		=			{
									    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()						)}'''						)

							SCREAMING_SNAKE_CASE :				List[str]		=			processed_features[self.model_input_names[0]]
							SCREAMING_SNAKE_CASE :				Optional[int]		=			(
							    return_attention_mask if return_attention_mask is not None else self.return_attention_mask
							)

							if len(lowerCamelCase_						) == 0:
									if return_attention_mask:
											SCREAMING_SNAKE_CASE :				List[str]		=			[]
									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

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

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

							for key, value in processed_features.items():
									if isinstance(value[0]      ,						(int, float)						):
											SCREAMING_SNAKE_CASE :				Dict		=			to_numpy(lowerCamelCase_						)
									else:
											SCREAMING_SNAKE_CASE :				Union[str, Any]		=			[to_numpy(lowerCamelCase_						) for v in value]

        # Convert padding_strategy in PaddingStrategy
							SCREAMING_SNAKE_CASE :				Optional[int]		=			self._get_padding_strategies(padding=lowerCamelCase_      ,						max_length=lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			processed_features[self.model_input_names[0]]

							SCREAMING_SNAKE_CASE :				int		=			len(lowerCamelCase_						)
							if not all(len(lowerCamelCase_						) == batch_size for v in processed_features.values()						):
									raise ValueError("""Some items in the output dictionary have a different batch size than others."""						)

							SCREAMING_SNAKE_CASE :				Dict		=			[]
							for i in range(lowerCamelCase_						):
									SCREAMING_SNAKE_CASE :				Optional[Any]		=			{k: v[i] for k, v in processed_features.items()}
									# truncation
									SCREAMING_SNAKE_CASE :				Any		=			self._truncate(
									    lowerCamelCase_      ,						max_length=lowerCamelCase_      ,						pad_to_multiple_of=lowerCamelCase_      ,						truncation=lowerCamelCase_      ,						)
									truncated_inputs.append(lowerCamelCase_						)

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

							SCREAMING_SNAKE_CASE :				str		=			{}
							for i in range(lowerCamelCase_						):
									# padding
									SCREAMING_SNAKE_CASE :				str		=			self._pad(
									    truncated_inputs[i]      ,						max_length=lowerCamelCase_      ,						padding_strategy=lowerCamelCase_      ,						pad_to_multiple_of=lowerCamelCase_      ,						return_attention_mask=lowerCamelCase_      ,						)

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

							return BatchFeature(lowerCamelCase_      ,						tensor_type=lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			Union[str, Any]      ,						lowerCamelCase_				:			Union[Dict[str, np.ndarray], BatchFeature]      ,						lowerCamelCase_				:			Optional[int] = None      ,						lowerCamelCase_				:			PaddingStrategy = PaddingStrategy.DO_NOT_PAD      ,						lowerCamelCase_				:			Optional[int] = None      ,						lowerCamelCase_				:			Optional[bool] = None      ,						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[str]		=			processed_features[self.model_input_names[0]]

							if padding_strategy == PaddingStrategy.LONGEST:
									SCREAMING_SNAKE_CASE :				Optional[int]		=			len(lowerCamelCase_						)

							if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
									SCREAMING_SNAKE_CASE :				int		=			((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

							SCREAMING_SNAKE_CASE :				List[str]		=			padding_strategy != PaddingStrategy.DO_NOT_PAD and len(lowerCamelCase_						) < max_length

							if return_attention_mask and "attention_mask" not in processed_features:
									SCREAMING_SNAKE_CASE :				List[str]		=			np.ones(len(lowerCamelCase_						)      ,						dtype=np.intaa						)

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

							return processed_features


					def lowerCamelCase_			(						self				:			List[Any]      ,						lowerCamelCase_				:			Union[Dict[str, np.ndarray], BatchFeature]      ,						lowerCamelCase_				:			Optional[int] = None      ,						lowerCamelCase_				:			Optional[int] = None      ,						lowerCamelCase_				:			Optional[bool] = None      ,						):

							'''simple docstring'''



							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."""						)

							SCREAMING_SNAKE_CASE :				Tuple		=			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):
									SCREAMING_SNAKE_CASE :				Tuple		=			((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

							SCREAMING_SNAKE_CASE :				Optional[int]		=			len(lowerCamelCase_						) > max_length

							if needs_to_be_truncated:
									SCREAMING_SNAKE_CASE :				Optional[Any]		=			processed_features[self.model_input_names[0]][:max_length]
									if "attention_mask" in processed_features:
											SCREAMING_SNAKE_CASE :				str		=			processed_features["""attention_mask"""][:max_length]

							return processed_features



					def lowerCamelCase_			(						self				:			Dict      ,						lowerCamelCase_				:			List[str]=False      ,						lowerCamelCase_				:			Dict=None						):

							'''simple docstring'''



							if padding is not False:
									if padding is True:
											SCREAMING_SNAKE_CASE :				Optional[int]		=			PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
									elif not isinstance(lowerCamelCase_      ,						lowerCamelCase_						):
											SCREAMING_SNAKE_CASE :				Tuple		=			PaddingStrategy(lowerCamelCase_						)
									elif isinstance(lowerCamelCase_      ,						lowerCamelCase_						):
											SCREAMING_SNAKE_CASE :				Union[str, Any]		=			padding
							else:
									SCREAMING_SNAKE_CASE :				Optional[Any]		=			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


__UpperCAmelCase            =       logging.get_logger(__name__)

__UpperCAmelCase            =       {
    """google/fnet-base""": """https://huggingface.co/google/fnet-base/resolve/main/config.json""",
    """google/fnet-large""": """https://huggingface.co/google/fnet-large/resolve/main/config.json"""
    # See all FNet models at https://huggingface.co/models?filter=fnet
}




class      UpperCamelCase__					(					lowercase_			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	'''fnet'''


					def __init__(						self				:			Any      ,						lowerCamelCase_				:			List[str]=3_20_00      ,						lowerCamelCase_				:			List[Any]=7_68      ,						lowerCamelCase_				:			Union[str, Any]=12      ,						lowerCamelCase_				:			Optional[Any]=30_72      ,						lowerCamelCase_				:			Optional[Any]="gelu_new"      ,						lowerCamelCase_				:			Any=0.1      ,						lowerCamelCase_				:			Union[str, Any]=5_12      ,						lowerCamelCase_				:			Optional[int]=4      ,						lowerCamelCase_				:			Optional[int]=0.02      ,						lowerCamelCase_				:			str=1e-12      ,						lowerCamelCase_				:			Any=False      ,						lowerCamelCase_				:			str=5_12      ,						lowerCamelCase_				:			str=3      ,						lowerCamelCase_				:			int=1      ,						lowerCamelCase_				:			Optional[Any]=2      ,						**lowerCamelCase_				:			Optional[int]      ,						):

							'''simple docstring'''



							super().__init__(pad_token_id=lowerCamelCase_      ,						bos_token_id=lowerCamelCase_      ,						eos_token_id=lowerCamelCase_      ,						**lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				Dict		=			vocab_size
							SCREAMING_SNAKE_CASE :				Dict		=			max_position_embeddings
							SCREAMING_SNAKE_CASE :				str		=			hidden_size
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			num_hidden_layers
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			intermediate_size
							SCREAMING_SNAKE_CASE :				int		=			hidden_act
							SCREAMING_SNAKE_CASE :				Dict		=			hidden_dropout_prob
							SCREAMING_SNAKE_CASE :				Tuple		=			initializer_range
							SCREAMING_SNAKE_CASE :				List[Any]		=			type_vocab_size
							SCREAMING_SNAKE_CASE :				Any		=			layer_norm_eps
							SCREAMING_SNAKE_CASE :				int		=			use_tpu_fourier_optimizations
							SCREAMING_SNAKE_CASE :				List[Any]		=			tpu_short_seq_length



