



'''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__:   int								=			logging.get_logger(__name__)

class 				SCREAMING_SNAKE_CASE(							A__			):







	"""simple docstring"""






	def __init__(						self			:     int		,			__snake_case			:     int		,			__snake_case			:     int		,			__snake_case			:     float		,			**__snake_case			:     Optional[Any]		)			->		Union[str, Any]:
								UpperCAmelCase :       Optional[Any] 							=		feature_size
								UpperCAmelCase :       Dict 							=		sampling_rate
								UpperCAmelCase :       Any 							=		padding_value

								UpperCAmelCase :       Union[str, Any] 							=		kwargs.pop('''padding_side'''		,			'''right'''		)
								UpperCAmelCase :       Dict 							=		kwargs.pop('''return_attention_mask'''		,			__snake_case		)

								super().__init__(**__snake_case		)







	def      A	(						self			:     Tuple		,			__snake_case			:     Union[
	        BatchFeature,
	        List[BatchFeature],
	        Dict[str, BatchFeature],
	        Dict[str, List[BatchFeature]],
	        List[Dict[str, BatchFeature]],
	    ]		,			__snake_case			:     Union[bool, str, PaddingStrategy] = True		,			__snake_case			:     Optional[int] = None		,			__snake_case			:     bool = False		,			__snake_case			:     Optional[int] = None		,			__snake_case			:     Optional[bool] = None		,			__snake_case			:     Optional[Union[str, TensorType]] = None		,			)			->		BatchFeature:
								# 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(__snake_case		,			(list, tuple)		) and isinstance(processed_features[0]		,			(dict, BatchFeature)		):
															UpperCAmelCase :       List[str] 							=		{
															    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()		)}"""		)

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

								if len(__snake_case		) == 0:
															if return_attention_mask:
																						UpperCAmelCase :       Optional[int] 							=		[]
															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

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

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

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

        # Convert padding_strategy in PaddingStrategy
								UpperCAmelCase :       List[Any] 							=		self._get_padding_strategies(padding=__snake_case		,			max_length=__snake_case		)

								UpperCAmelCase :       Any 							=		processed_features[self.model_input_names[0]]

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

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

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

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

															for key, value in outputs.items():
																						if key not in batch_outputs:
																													UpperCAmelCase :       Union[str, Any] 							=		[]
																						if value.dtype is np.dtype(np.floataa		):
																													UpperCAmelCase :       Optional[Any] 							=		value.astype(np.floataa		)
																						batch_outputs[key].append(__snake_case		)

								return BatchFeature(__snake_case		,			tensor_type=__snake_case		)







	def      A	(						self			:     Dict		,			__snake_case			:     Union[Dict[str, np.ndarray], BatchFeature]		,			__snake_case			:     Optional[int] = None		,			__snake_case			:     PaddingStrategy = PaddingStrategy.DO_NOT_PAD		,			__snake_case			:     Optional[int] = None		,			__snake_case			:     Optional[bool] = None		,			)			->		dict:
								UpperCAmelCase :       Union[str, Any] 							=		processed_features[self.model_input_names[0]]

								if padding_strategy == PaddingStrategy.LONGEST:
															UpperCAmelCase :       int 							=		len(__snake_case		)

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

								UpperCAmelCase :       str 							=		padding_strategy != PaddingStrategy.DO_NOT_PAD and len(__snake_case		) < max_length

								if return_attention_mask and "attention_mask" not in processed_features:
															UpperCAmelCase :       List[Any] 							=		np.ones(len(__snake_case		)		,			dtype=np.intaa		)

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

								return processed_features







	def      A	(						self			:     Tuple		,			__snake_case			:     Union[Dict[str, np.ndarray], BatchFeature]		,			__snake_case			:     Optional[int] = None		,			__snake_case			:     Optional[int] = None		,			__snake_case			:     Optional[bool] = None		,			)			->		Union[str, Any]:
								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.'''		)

								UpperCAmelCase :       Any 							=		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):
															UpperCAmelCase :       Optional[Any] 							=		((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

								UpperCAmelCase :       Union[str, Any] 							=		len(__snake_case		) > max_length

								if needs_to_be_truncated:
															UpperCAmelCase :       List[Any] 							=		processed_features[self.model_input_names[0]][:max_length]
															if "attention_mask" in processed_features:
																						UpperCAmelCase :       Union[str, Any] 							=		processed_features['''attention_mask'''][:max_length]

								return processed_features







	def      A	(						self			:     Union[str, Any]		,			__snake_case			:     List[str]=False		,			__snake_case			:     Any=None		)			->		Union[str, Any]:

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






# coding=utf-8
# Copyright 2020 The HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# this script dumps information about the environment

import os
import sys

import transformers


UpperCamelCase__:   Optional[int]								=			"3"

print("Python version:", sys.version)
print("transformers version:", transformers.__version__)

try:
						import torch

						print("Torch version:", torch.__version__)
						print("Cuda available:", torch.cuda.is_available())
						print("Cuda version:", torch.version.cuda)
						print("CuDNN version:", torch.backends.cudnn.version())
						print("Number of GPUs available:", torch.cuda.device_count())
						print("NCCL version:", torch.cuda.nccl.version())
except ImportError:
						print("Torch version:", None)

try:
						import deepspeed

						print("DeepSpeed version:", deepspeed.__version__)
except ImportError:
						print("DeepSpeed version:", None)

try:
						import tensorflow as tf

						print("TensorFlow version:", tf.__version__)
						print("TF GPUs available:", bool(tf.config.list_physical_devices("GPU")))
						print("Number of TF GPUs available:", len(tf.config.list_physical_devices("GPU")))
except ImportError:
						print("TensorFlow version:", None)





