



"""simple docstring"""






import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


_lowercase			:			Optional[Any]										=						{
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL,
}

_lowercase			:			List[str]										=						logging.WARNING






def 					snake_case__       (		):
			"""simple docstring"""
			lowerCamelCase__		:		Dict		     =os.getenv('''DATASETS_VERBOSITY'''							,		__lowerCamelCase     )
			if env_level_str:
						if env_level_str in log_levels:
									return log_levels[env_level_str]
						else:
									logging.getLogger().warning(
									    f'''Unknown option DATASETS_VERBOSITY={env_level_str}, '''
									    f'''has to be one of: { ", ".join(log_levels.keys()     ) }'''     )
			return _default_log_level






def 					snake_case__       (		):
			"""simple docstring"""
			return __name__.split('''.'''     )[0]






def 					snake_case__       (		):
			"""simple docstring"""
			return logging.getLogger(_get_library_name()     )






def 					snake_case__       (		):
			"""simple docstring"""
			# Apply our default configuration to the library root logger.
			lowerCamelCase__		:		Union[str, Any]		     =_get_library_root_logger()
			library_root_logger.setLevel(_get_default_logging_level()     )






def 					snake_case__       (		):
			"""simple docstring"""
			lowerCamelCase__		:		Any		     =_get_library_root_logger()
			library_root_logger.setLevel(logging.NOTSET     )






def 					snake_case__       (		__lowerCamelCase    :   Optional[str] = None     ):
			"""simple docstring"""
			if name is None:
						lowerCamelCase__		:		List[Any]		     =_get_library_name()
			return logging.getLogger(__lowerCamelCase     )






def 					snake_case__       (		):
			"""simple docstring"""
			return _get_library_root_logger().getEffectiveLevel()






def 					snake_case__       (		__lowerCamelCase    :   int     ):
			"""simple docstring"""
			_get_library_root_logger().setLevel(__lowerCamelCase     )






def 					snake_case__       (		):
			"""simple docstring"""
			return set_verbosity(__lowerCamelCase     )






def 					snake_case__       (		):
			"""simple docstring"""
			return set_verbosity(__lowerCamelCase     )






def 					snake_case__       (		):
			"""simple docstring"""
			return set_verbosity(__lowerCamelCase     )






def 					snake_case__       (		):
			"""simple docstring"""
			return set_verbosity(__lowerCamelCase     )






def 					snake_case__       (		):
			"""simple docstring"""
			lowerCamelCase__		:		str		     =False






def 					snake_case__       (		):
			"""simple docstring"""
			lowerCamelCase__		:		Optional[Any]		     =True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()

class 	__SCREAMING_SNAKE_CASE     :


					'''simple docstring'''





					def __init__(	self							:  str,  *lowerCamelCase							:  Optional[int],  **lowerCamelCase							:  List[Any]					)-> Tuple:  # pylint: disable=unused-argument
								lowerCamelCase__		:		Dict		     =args[0] if args else None



					def __iter__(	self							:  Any					)-> Optional[int]:
								return iter(self._iterator					)



					def __getattr__(	self							:  List[Any],  lowerCamelCase							:  int					)-> Optional[Any]:

								def empty_fn(*lowerCamelCase							:  Tuple,  **lowerCamelCase							:  int					):  # pylint: disable=unused-argument
											return

								return empty_fn



					def __enter__(	self							:  str					)-> Tuple:
								return self




					def __exit__(	self							:  Optional[Any],  lowerCamelCase							:  Union[str, Any],  lowerCamelCase							:  List[Any],  lowerCamelCase							:  Optional[Any]					)-> Tuple:
								return





_lowercase			:			Dict										=						True

class 	__SCREAMING_SNAKE_CASE     :


					'''simple docstring'''





					def __call__(	self							:  Optional[Any],  *lowerCamelCase							:  Optional[Any],  lowerCamelCase							:  List[Any]=False,  **lowerCamelCase							:  List[str]					)-> int:
								if _tqdm_active and not disable:
											return tqdm_lib.tqdm(*lowerCamelCase,  **lowerCamelCase					)
								else:
											return EmptyTqdm(*lowerCamelCase,  **lowerCamelCase					)



					def 		snake_case	(	self							:  Any,  *lowerCamelCase							:  Optional[Any],  **lowerCamelCase							:  Tuple					)-> Any:
								lowerCamelCase__		:		List[str]		     =None
								if _tqdm_active:
											return tqdm_lib.tqdm.set_lock(*lowerCamelCase,  **lowerCamelCase					)




					def 		snake_case	(	self							:  str					)-> Tuple:
								if _tqdm_active:
											return tqdm_lib.tqdm.get_lock()





_lowercase			:			List[str]										=						_tqdm_cls()






def 					snake_case__       (		):
			"""simple docstring"""
			global _tqdm_active
			return bool(_tqdm_active     )






def 					snake_case__       (		):
			"""simple docstring"""
			global _tqdm_active
			lowerCamelCase__		:		Any		     =True






def 					snake_case__       (		):
			"""simple docstring"""
			global _tqdm_active
			lowerCamelCase__		:		Optional[Any]		     =False









"""simple docstring"""






from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


_lowercase			:			List[str]										=						logging.get_logger(__name__)






def 					snake_case__       (		__lowerCamelCase    :   Union[tf.Tensor, np.ndarray]     ):
			"""simple docstring"""
			if isinstance(__lowerCamelCase							,		np.ndarray     ):
						return list(tensor.shape     )

			lowerCamelCase__		:		List[Any]		     =tf.shape(__lowerCamelCase     )

			if tensor.shape == tf.TensorShape(__lowerCamelCase     ):
						return dynamic

			lowerCamelCase__		:		List[str]		     =tensor.shape.as_list()

			return [dynamic[i] if s is None else s for i, s in enumerate(__lowerCamelCase     )]






def 					snake_case__       (		__lowerCamelCase    :   tf.Tensor							,		__lowerCamelCase    :   Optional[int] = None							,		__lowerCamelCase    :   Optional[str] = None     ):
			"""simple docstring"""
			return tf.nn.softmax(logits=logits + 1e-9							,		axis=__lowerCamelCase							,		name=__lowerCamelCase     )






def 					snake_case__       (		__lowerCamelCase    :   Optional[Any]							,		__lowerCamelCase    :   str							,		__lowerCamelCase    :   Optional[int]							,		__lowerCamelCase    :   Any=1e-5							,		__lowerCamelCase    :   str=-1     ):
			"""simple docstring"""
			# This is a very simplified functional layernorm, designed to duplicate
			# the functionality of PyTorch nn.functional.layer_norm when this is needed to port
			# models in Transformers.

			if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(__lowerCamelCase							,		__lowerCamelCase     ):
						raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.'''     )

			# Get mean and variance on the axis to be normalized
			lowerCamelCase__     ,       lowerCamelCase__		:		Optional[int]		     =tf.nn.moments(__lowerCamelCase							,		axes=[axis]							,		keepdims=__lowerCamelCase     )

			if axis != -1:
						# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
						# on every dimension except axis
						lowerCamelCase__		:		Optional[Any]		     =[1] * inputs.shape.rank
						lowerCamelCase__		:		Union[str, Any]		     =shape_list(__lowerCamelCase     )[axis]
						lowerCamelCase__		:		Optional[Any]		     =tf.reshape(__lowerCamelCase							,		__lowerCamelCase     )
						lowerCamelCase__		:		Any		     =tf.reshape(__lowerCamelCase							,		__lowerCamelCase     )

			# Compute layer normalization using the batch_normalization
			# function.
			lowerCamelCase__		:		List[str]		     =tf.nn.batch_normalization(
			    __lowerCamelCase							,		__lowerCamelCase							,		__lowerCamelCase							,		offset=__lowerCamelCase							,		scale=__lowerCamelCase							,		variance_epsilon=__lowerCamelCase							,		)
			return outputs






def 					snake_case__       (		__lowerCamelCase    :   Any							,		__lowerCamelCase    :   List[Any]=0							,		__lowerCamelCase    :   int=-1     ):
			"""simple docstring"""
			# Replicates the behavior of torch.flatten in TF

			# If end_dim or start_dim is negative, count them from the end
			if end_dim < 0:
						end_dim += input.shape.rank
			if start_dim < 0:
						start_dim += input.shape.rank

			if start_dim == end_dim:
						return input

			lowerCamelCase__		:		Optional[int]		     =tf.shape(__lowerCamelCase     )
			lowerCamelCase__		:		Optional[int]		     =tf.math.reduce_prod(in_shape[start_dim : end_dim + 1]     )
			lowerCamelCase__		:		List[Any]		     =tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]							,		axis=0     )
			return tf.reshape(__lowerCamelCase							,		__lowerCamelCase     )






def 					snake_case__       (		__lowerCamelCase    :   tf.Tensor     ):
			"""simple docstring"""
			if not isinstance(__lowerCamelCase							,		tf.Tensor     ):
						lowerCamelCase__		:		List[Any]		     =tf.convert_to_tensor(__lowerCamelCase     )  # Catches stray NumPy inputs
			if encoder_attention_mask.shape.rank == 3:
						lowerCamelCase__		:		int		     =encoder_attention_mask[:, None, :, :]
			if encoder_attention_mask.shape.rank == 2:
						lowerCamelCase__		:		int		     =encoder_attention_mask[:, None, None, :]
			# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
			# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
			# /transformer/transformer_layers.py#L270
			# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
			# encoder_extended_attention_mask.transpose(-1, -2))
			lowerCamelCase__		:		str		     =(
			    tf.cast(1							,		encoder_attention_mask.dtype     ) - encoder_extended_attention_mask
			) * encoder_extended_attention_mask.dtype.min

			return encoder_extended_attention_mask






def 					snake_case__       (		__lowerCamelCase    :   tf.Tensor							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   str = "input_ids"     ):
			"""simple docstring"""
			tf.debugging.assert_less(
			    __lowerCamelCase							,		tf.cast(__lowerCamelCase							,		dtype=tensor.dtype     )							,		message=(
			        f'''The maximum value of {tensor_name} ({tf.math.reduce_max(__lowerCamelCase     )}) must be smaller than the embedding '''
			        f'''layer\'s input dimension ({embed_dim}). The likely cause is some problem at tokenization time.'''
			    )							,		)






def 					snake_case__       (		__lowerCamelCase    :   Tuple							,		__lowerCamelCase    :   List[str]							,		__lowerCamelCase    :   Dict     ):
			"""simple docstring"""
			lowerCamelCase__		:		Any		     =64512
			# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
			# because in that case even chunking the array would not make the saving
			# possible.
			lowerCamelCase__		:		Tuple		     =[x for x in data if len(__lowerCamelCase     ) > HDF5_OBJECT_HEADER_LIMIT]

			# Expecting this to never be true.
			if bad_attributes:
						raise RuntimeError(
						    '''The following attributes cannot be saved to HDF5 file because '''
						    f'''they are larger than {HDF5_OBJECT_HEADER_LIMIT} '''
						    f'''bytes: {bad_attributes}'''     )

			lowerCamelCase__		:		Optional[Any]		     =np.asarray(__lowerCamelCase     )

			lowerCamelCase__		:		str		     =1
			lowerCamelCase__		:		List[Any]		     =np.array_split(__lowerCamelCase							,		__lowerCamelCase     )

			# This will never loop forever thanks to the test above.
			while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data     ):
						num_chunks += 1
						lowerCamelCase__		:		Union[str, Any]		     =np.array_split(__lowerCamelCase							,		__lowerCamelCase     )

			if num_chunks > 1:
						for chunk_id, chunk_data in enumerate(__lowerCamelCase     ):
									lowerCamelCase__		:		List[str]		     =chunk_data
			else:
						lowerCamelCase__		:		Dict		     =data






def 					snake_case__       (		__lowerCamelCase    :   Dict							,		__lowerCamelCase    :   Optional[Any]     ):
			"""simple docstring"""
			if name in group.attrs:
						lowerCamelCase__		:		Optional[int]		     =[n.decode('''utf8'''     ) if hasattr(__lowerCamelCase							,		'''decode'''     ) else n for n in group.attrs[name]]
			else:
						lowerCamelCase__		:		str		     =[]
						lowerCamelCase__		:		str		     =0
						while "%s%d" % (name, chunk_id) in group.attrs:
									data.extend(
									    [n.decode('''utf8'''     ) if hasattr(__lowerCamelCase							,		'''decode'''     ) else n for n in group.attrs['''%s%d''' % (name, chunk_id)]]     )
									chunk_id += 1
			return data






def 					snake_case__       (		__lowerCamelCase    :   Dict     ):
			"""simple docstring"""

			def _expand_single_ad_tensor(__lowerCamelCase    :   List[Any]     ):
						if isinstance(__lowerCamelCase							,		tf.Tensor     ) and t.shape.rank == 1:
									return tf.expand_dims(__lowerCamelCase							,		axis=-1     )
						return t

			return tf.nest.map_structure(_expand_single_ad_tensor							,		__lowerCamelCase     )




