import io
import json

import fsspec
import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.json import JsonDatasetReader, JsonDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Dict		, _SCREAMING_SNAKE_CASE     :				Any			):
						assert isinstance(_UpperCamelCase		, _UpperCamelCase			)
						assert dataset.num_rows == 4
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_1", "col_2", "col_3"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype






@pytest.mark.parametrize("""keep_in_memory"""		, [False, True]			)
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				str		, _SCREAMING_SNAKE_CASE     :				Optional[Any]		, _SCREAMING_SNAKE_CASE     :				Optional[Any]			):
						UpperCamelCase_		:							Any  =		tmp_path / """cache"""
						UpperCamelCase_		:							Optional[Any]  =		{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												UpperCamelCase_		:							Dict  =		JsonDatasetReader(_UpperCamelCase		, cache_dir=_UpperCamelCase		, keep_in_memory=_UpperCamelCase			).read()
						_check_json_dataset(_UpperCamelCase		, _UpperCamelCase			)






@pytest.mark.parametrize(
    """features"""		, [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]		, )
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Optional[Any]		, _SCREAMING_SNAKE_CASE     :				Union[str, Any]		, _SCREAMING_SNAKE_CASE     :				Tuple			):
						UpperCamelCase_		:							Optional[int]  =		tmp_path / """cache"""
						UpperCamelCase_		:							List[Any]  =		{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						UpperCamelCase_		:							Tuple  =		features.copy() if features else default_expected_features
						UpperCamelCase_		:							Union[str, Any]  =		(
						    Features({feature: Value(_UpperCamelCase			) for feature, dtype in features.items()}			) if features is not None else None
						)
						UpperCamelCase_		:							int  =		JsonDatasetReader(_UpperCamelCase		, features=_UpperCamelCase		, cache_dir=_UpperCamelCase			).read()
						_check_json_dataset(_UpperCamelCase		, _UpperCamelCase			)






@pytest.mark.parametrize(
    """features"""		, [
        None,
        {"""col_3""": """float64""", """col_1""": """string""", """col_2""": """int64"""},
    ]		, )
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				List[Any]		, _SCREAMING_SNAKE_CASE     :				List[str]		, _SCREAMING_SNAKE_CASE     :				List[Any]			):
						UpperCamelCase_		:							List[Any]  =		tmp_path / """cache"""
						UpperCamelCase_		:							str  =		{"""col_3""": """float64""", """col_1""": """string""", """col_2""": """int64"""}
						UpperCamelCase_		:							Union[str, Any]  =		features.copy() if features else default_expected_features
						UpperCamelCase_		:							int  =		(
						    Features({feature: Value(_UpperCamelCase			) for feature, dtype in features.items()}			) if features is not None else None
						)
						UpperCamelCase_		:							int  =		JsonDatasetReader(_UpperCamelCase		, features=_UpperCamelCase		, cache_dir=_UpperCamelCase			).read()
						assert isinstance(_UpperCamelCase		, _UpperCamelCase			)
						assert dataset.num_rows == 2
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_3", "col_1", "col_2"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Optional[Any]		, _SCREAMING_SNAKE_CASE     :				str			):
						# jsonl_312_path features are {"col_3": "float64", "col_1": "string", "col_2": "int64"}
						UpperCamelCase_		:							Dict  =		{"""col_2""": """int64""", """col_3""": """float64""", """col_1""": """string"""}
						UpperCamelCase_		:							Optional[int]  =		features.copy()
						UpperCamelCase_		:							Dict  =		(
						    Features({feature: Value(_UpperCamelCase			) for feature, dtype in features.items()}			) if features is not None else None
						)
						UpperCamelCase_		:							Tuple  =		tmp_path / """cache"""
						UpperCamelCase_		:							Tuple  =		JsonDatasetReader(_UpperCamelCase		, features=_UpperCamelCase		, cache_dir=_UpperCamelCase			).read()
						assert isinstance(_UpperCamelCase		, _UpperCamelCase			)
						assert dataset.num_rows == 2
						assert dataset.num_columns == 3
						assert dataset.column_names == ["col_2", "col_3", "col_1"]
						for feature, expected_dtype in expected_features.items():
												assert dataset.features[feature].dtype == expected_dtype






@pytest.mark.parametrize("""split"""		, [None, NamedSplit("""train"""			), """train""", """test"""]			)
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				List[str]		, _SCREAMING_SNAKE_CASE     :				Any		, _SCREAMING_SNAKE_CASE     :				Optional[Any]			):
						UpperCamelCase_		:							Optional[Any]  =		tmp_path / """cache"""
						UpperCamelCase_		:							Union[str, Any]  =		{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						UpperCamelCase_		:							Tuple  =		JsonDatasetReader(_UpperCamelCase		, cache_dir=_UpperCamelCase		, split=_UpperCamelCase			).read()
						_check_json_dataset(_UpperCamelCase		, _UpperCamelCase			)
						assert dataset.split == split if split else "train"






@pytest.mark.parametrize("""path_type"""		, [str, list]			)
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Optional[int]		, _SCREAMING_SNAKE_CASE     :				Optional[int]		, _SCREAMING_SNAKE_CASE     :				Union[str, Any]			):
						if issubclass(_UpperCamelCase		, _UpperCamelCase			):
												UpperCamelCase_		:							Any  =		jsonl_path
						elif issubclass(_UpperCamelCase		, _UpperCamelCase			):
												UpperCamelCase_		:							Dict  =		[jsonl_path]
						UpperCamelCase_		:							str  =		tmp_path / """cache"""
						UpperCamelCase_		:							Optional[Any]  =		{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						UpperCamelCase_		:							Optional[int]  =		JsonDatasetReader(_UpperCamelCase		, cache_dir=_UpperCamelCase			).read()
						_check_json_dataset(_UpperCamelCase		, _UpperCamelCase			)






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				str		, _SCREAMING_SNAKE_CASE     :				Any		, _SCREAMING_SNAKE_CASE     :				List[str]=("train",)			):
						assert isinstance(_UpperCamelCase		, _UpperCamelCase			)
						for split in splits:
												UpperCamelCase_		:							Tuple  =		dataset_dict[split]
												assert dataset.num_rows == 4
												assert dataset.num_columns == 3
												assert dataset.column_names == ["col_1", "col_2", "col_3"]
												for feature, expected_dtype in expected_features.items():
																		assert dataset.features[feature].dtype == expected_dtype






@pytest.mark.parametrize("""keep_in_memory"""		, [False, True]			)
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				List[str]		, _SCREAMING_SNAKE_CASE     :				Dict		, _SCREAMING_SNAKE_CASE     :				Optional[int]			):
						UpperCamelCase_		:							Union[str, Any]  =		tmp_path / """cache"""
						UpperCamelCase_		:							Dict  =		{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
												UpperCamelCase_		:							int  =		JsonDatasetReader({"""train""": jsonl_path}		, cache_dir=_UpperCamelCase		, keep_in_memory=_UpperCamelCase			).read()
						_check_json_datasetdict(_UpperCamelCase		, _UpperCamelCase			)






@pytest.mark.parametrize(
    """features"""		, [
        None,
        {"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""},
        {"""col_1""": """string""", """col_2""": """string""", """col_3""": """string"""},
        {"""col_1""": """int32""", """col_2""": """int32""", """col_3""": """int32"""},
        {"""col_1""": """float32""", """col_2""": """float32""", """col_3""": """float32"""},
    ]		, )
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Any		, _SCREAMING_SNAKE_CASE     :				Optional[int]		, _SCREAMING_SNAKE_CASE     :				List[Any]			):
						UpperCamelCase_		:							int  =		tmp_path / """cache"""
						UpperCamelCase_		:							int  =		{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						UpperCamelCase_		:							int  =		features.copy() if features else default_expected_features
						UpperCamelCase_		:							List[Any]  =		(
						    Features({feature: Value(_UpperCamelCase			) for feature, dtype in features.items()}			) if features is not None else None
						)
						UpperCamelCase_		:							Dict  =		JsonDatasetReader({"""train""": jsonl_path}		, features=_UpperCamelCase		, cache_dir=_UpperCamelCase			).read()
						_check_json_datasetdict(_UpperCamelCase		, _UpperCamelCase			)






@pytest.mark.parametrize("""split"""		, [None, NamedSplit("""train"""			), """train""", """test"""]			)
def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Tuple		, _SCREAMING_SNAKE_CASE     :				List[str]		, _SCREAMING_SNAKE_CASE     :				Union[str, Any]			):
						if split:
												UpperCamelCase_		:							Any  =		{split: jsonl_path}
						else:
												UpperCamelCase_		:							Optional[int]  =		"""train"""
												UpperCamelCase_		:							List[Any]  =		{"""train""": jsonl_path, """test""": jsonl_path}
						UpperCamelCase_		:							Dict  =		tmp_path / """cache"""
						UpperCamelCase_		:							List[Any]  =		{"""col_1""": """string""", """col_2""": """int64""", """col_3""": """float64"""}
						UpperCamelCase_		:							List[Any]  =		JsonDatasetReader(_UpperCamelCase		, cache_dir=_UpperCamelCase			).read()
						_check_json_datasetdict(_UpperCamelCase		, _UpperCamelCase		, splits=list(path.keys()			)			)
						assert all(dataset[split].split == split for split in path.keys()			)






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				int			):
						return json.load(_UpperCamelCase			)






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				int			):
						return [json.loads(_UpperCamelCase			) for line in buffer]







class        UpperCamelCase						:





						@pytest.mark.parametrize("""lines, load_json_function"""			,     [(True, load_json_lines), (False, load_json)]						)
						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				List[Any]:
												with io.BytesIO() as buffer:
																		JsonDatasetWriter(__UpperCAmelCase			,     __UpperCAmelCase			,     lines=__UpperCAmelCase						).write()
																		buffer.seek(0						)
																		UpperCamelCase_		:							List[str]  =		load_json_function(__UpperCAmelCase						)
												assert isinstance(__UpperCAmelCase			,     __UpperCAmelCase						)
												assert isinstance(exported_content[0]			,     __UpperCAmelCase						)
												assert len(__UpperCAmelCase						) == 10





						@pytest.mark.parametrize(
						    """orient, container, keys, len_at"""			,     [
						        ("""records""", list, {"""tokens""", """labels""", """answers""", """id"""}, None),
						        ("""split""", dict, {"""columns""", """data"""}, """data"""),
						        ("""index""", dict, set("""0123456789"""						), None),
						        ("""columns""", dict, {"""tokens""", """labels""", """answers""", """id"""}, """tokens"""),
						        ("""values""", list, None, None),
						        ("""table""", dict, {"""schema""", """data"""}, """data"""),
						    ]			,     )
						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Union[str, Any]:
												with io.BytesIO() as buffer:
																		JsonDatasetWriter(__UpperCAmelCase			,     __UpperCAmelCase			,     lines=__UpperCAmelCase			,     orient=__UpperCAmelCase						).write()
																		buffer.seek(0						)
																		UpperCamelCase_		:							Any  =		load_json(__UpperCAmelCase						)
												assert isinstance(__UpperCAmelCase			,     __UpperCAmelCase						)
												if keys:
																		if container is dict:
																								assert exported_content.keys() == keys
																		else:
																								assert exported_content[0].keys() == keys
												else:
																		assert not hasattr(__UpperCAmelCase			,     """keys"""						) and not hasattr(exported_content[0]			,     """keys"""						)
												if len_at:
																		assert len(exported_content[len_at]						) == 10
												else:
																		assert len(__UpperCAmelCase						) == 10





						@pytest.mark.parametrize("""lines, load_json_function"""			,     [(True, load_json_lines), (False, load_json)]						)
						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Optional[Any]:
												with io.BytesIO() as buffer:
																		JsonDatasetWriter(__UpperCAmelCase			,     __UpperCAmelCase			,     lines=__UpperCAmelCase			,     num_proc=2						).write()
																		buffer.seek(0						)
																		UpperCamelCase_		:							Optional[Any]  =		load_json_function(__UpperCAmelCase						)
												assert isinstance(__UpperCAmelCase			,     __UpperCAmelCase						)
												assert isinstance(exported_content[0]			,     __UpperCAmelCase						)
												assert len(__UpperCAmelCase						) == 10





						@pytest.mark.parametrize(
						    """orient, container, keys, len_at"""			,     [
						        ("""records""", list, {"""tokens""", """labels""", """answers""", """id"""}, None),
						        ("""split""", dict, {"""columns""", """data"""}, """data"""),
						        ("""index""", dict, set("""0123456789"""						), None),
						        ("""columns""", dict, {"""tokens""", """labels""", """answers""", """id"""}, """tokens"""),
						        ("""values""", list, None, None),
						        ("""table""", dict, {"""schema""", """data"""}, """data"""),
						    ]			,     )
						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				int:
												with io.BytesIO() as buffer:
																		JsonDatasetWriter(__UpperCAmelCase			,     __UpperCAmelCase			,     lines=__UpperCAmelCase			,     orient=__UpperCAmelCase			,     num_proc=2						).write()
																		buffer.seek(0						)
																		UpperCamelCase_		:							Dict  =		load_json(__UpperCAmelCase						)
												assert isinstance(__UpperCAmelCase			,     __UpperCAmelCase						)
												if keys:
																		if container is dict:
																								assert exported_content.keys() == keys
																		else:
																								assert exported_content[0].keys() == keys
												else:
																		assert not hasattr(__UpperCAmelCase			,     """keys"""						) and not hasattr(exported_content[0]			,     """keys"""						)
												if len_at:
																		assert len(exported_content[len_at]						) == 10
												else:
																		assert len(__UpperCAmelCase						) == 10





						def        A_							(self			,     __UpperCamelCase						)				->				Union[str, Any]:
												with pytest.raises(__UpperCAmelCase						):
																		with io.BytesIO() as buffer:
																								JsonDatasetWriter(__UpperCAmelCase			,     __UpperCAmelCase			,     num_proc=0						)





						@pytest.mark.parametrize("""compression, extension"""			,     [("""gzip""", """gz"""), ("""bz2""", """bz2"""), ("""xz""", """xz""")]						)
						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase			,     __UpperCamelCase						)				->				int:
												UpperCamelCase_		:							str  =		tmp_path_factory.mktemp("""data"""						) / f'''test.json.{extension}'''
												UpperCamelCase_		:							Optional[int]  =		str(shared_datadir / f'''test_file.json.{extension}'''						)
												JsonDatasetWriter(__UpperCAmelCase			,     __UpperCAmelCase			,     compression=__UpperCAmelCase						).write()

												with fsspec.open(__UpperCAmelCase			,     """rb"""			,     compression="""infer"""						) as f:
																		UpperCamelCase_		:							Any  =		f.read()
												with fsspec.open(__UpperCAmelCase			,     """rb"""			,     compression="""infer"""						) as f:
																		UpperCamelCase_		:							List[str]  =		f.read()
												assert exported_content == original_content











import tempfile
import unittest

from transformers import TaConfig, is_torch_available
from transformers.testing_utils import (
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
    torch_device,
)

from ...generation.test_utils import GenerationTesterMixin
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import AutoTokenizer, UMTaForConditionalGeneration, UMTaForQuestionAnswering, UMTaModel



class 			__lowerCAmelCase  :




 def __init__(    self						,					__UpperCAmelCase						,					__UpperCAmelCase=99						,					__UpperCAmelCase=13						,					__UpperCAmelCase=7						,					__UpperCAmelCase=9						,					__UpperCAmelCase=True						,					__UpperCAmelCase=True						,					__UpperCAmelCase=False						,					__UpperCAmelCase=32						,					__UpperCAmelCase=5						,					__UpperCAmelCase=4						,					__UpperCAmelCase=37						,					__UpperCAmelCase=8						,					__UpperCAmelCase=0.1						,					__UpperCAmelCase=0.002						,					__UpperCAmelCase=1						,					__UpperCAmelCase=0						,					__UpperCAmelCase=0						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None						,					):



    '''simple docstring'''
    __lowerCamelCase    				=     parent
    __lowerCamelCase    				=     batch_size
    __lowerCamelCase    				=     encoder_seq_length
    __lowerCamelCase    				=     decoder_seq_length
    # For common tests
    __lowerCamelCase    				=     self.decoder_seq_length
    __lowerCamelCase    				=     is_training
    __lowerCamelCase    				=     use_attention_mask
    __lowerCamelCase    				=     use_labels
    __lowerCamelCase    				=     vocab_size
    __lowerCamelCase    				=     hidden_size
    __lowerCamelCase    				=     num_hidden_layers
    __lowerCamelCase    				=     num_attention_heads
    __lowerCamelCase    				=     d_ff
    __lowerCamelCase    				=     relative_attention_num_buckets
    __lowerCamelCase    				=     dropout_rate
    __lowerCamelCase    				=     initializer_factor
    __lowerCamelCase    				=     eos_token_id
    __lowerCamelCase    				=     pad_token_id
    __lowerCamelCase    				=     decoder_start_token_id
    __lowerCamelCase    				=     None
    __lowerCamelCase    				=     decoder_layers




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    return TaConfig.from_pretrained('''google/umt5-base'''					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None						,					__UpperCAmelCase=None						,					):



    '''simple docstring'''
    if attention_mask is None:
       __lowerCamelCase    				=     input_ids.ne(config.pad_token_id					)
    if decoder_attention_mask is None:
       __lowerCamelCase    				=     decoder_input_ids.ne(config.pad_token_id					)
    if head_mask is None:
       __lowerCamelCase    				=     torch.ones(config.num_hidden_layers						,					config.num_attention_heads						,					device=__UpperCAmelCase					)
    if decoder_head_mask is None:
       __lowerCamelCase    				=     torch.ones(config.num_decoder_layers						,					config.num_attention_heads						,					device=__UpperCAmelCase					)
    if cross_attn_head_mask is None:
       __lowerCamelCase    				=     torch.ones(
           config.num_decoder_layers						,					config.num_attention_heads						,					device=__UpperCAmelCase					)
    return {
        "input_ids": input_ids,
        "decoder_input_ids": decoder_input_ids,
        "attention_mask": attention_mask,
        "decoder_attention_mask": decoder_attention_mask,
        "head_mask": head_mask,
        "decoder_head_mask": decoder_head_mask,
        "cross_attn_head_mask": cross_attn_head_mask,
    }




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     ids_tensor([self.batch_size, self.encoder_seq_length]						,					self.vocab_size					)
    __lowerCamelCase    				=     ids_tensor([self.batch_size, self.decoder_seq_length]						,					self.vocab_size					)

    # we need to clamp the input ids here to avoid having pad token in between
    # this is because for NllbMoe the position_ids are prepared such that
    # all pad tokens have pos id = 2 and rest are between 2..seq_length
    # and the seq_length here is seq_length - num_pad_tokens
    # but when using past, there is no way of knowing if the past input ids had
    # pad tokens in them, which results in incorrect seq_lenth and which in turn results in
    # position_ids being off by num_pad_tokens in past input
    __lowerCamelCase    				=     input_ids.clamp(self.pad_token_id + 1					)
    __lowerCamelCase    				=     decoder_input_ids.clamp(self.pad_token_id + 1					)

    __lowerCamelCase    				=     self.get_config()
    __lowerCamelCase    				=     config.num_attention_heads
    __lowerCamelCase    				=     self.prepare_inputs_dict(__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					)
    return config, input_dict




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase				,__lowerCamelCase    				=     self.prepare_config_and_inputs()
    return config, inputs_dict




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    return TaConfig(
        vocab_size=166						,					d_model=self.hidden_size						,					d_ff=self.d_ff						,					d_kv=self.hidden_size // self.num_attention_heads						,					num_layers=self.num_hidden_layers						,					num_decoder_layers=self.decoder_layers						,					num_heads=self.num_attention_heads						,					relative_attention_num_buckets=self.relative_attention_num_buckets						,					dropout_rate=self.dropout_rate						,					initializer_factor=self.initializer_factor						,					eos_token_id=self.eos_token_id						,					bos_token_id=self.pad_token_id						,					pad_token_id=self.pad_token_id						,					decoder_start_token_id=self.decoder_start_token_id						,					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    return TaConfig(
        vocab_size=self.vocab_size						,					d_model=self.hidden_size						,					d_ff=self.d_ff						,					d_kv=self.hidden_size // self.num_attention_heads						,					num_layers=self.num_hidden_layers						,					num_decoder_layers=self.decoder_layers						,					num_heads=self.num_attention_heads						,					relative_attention_num_buckets=self.relative_attention_num_buckets						,					dropout_rate=self.dropout_rate						,					initializer_factor=self.initializer_factor						,					eos_token_id=self.eos_token_id						,					bos_token_id=self.pad_token_id						,					pad_token_id=self.pad_token_id						,					decoder_start_token_id=self.decoder_start_token_id						,					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					):



    '''simple docstring'''
    __lowerCamelCase    				=     UMTaModel(config=__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()
    __lowerCamelCase    				=     model(
        input_ids=__UpperCAmelCase						,					decoder_input_ids=__UpperCAmelCase						,					attention_mask=__UpperCAmelCase						,					decoder_attention_mask=__UpperCAmelCase						,					)
    __lowerCamelCase    				=     model(input_ids=__UpperCAmelCase						,					decoder_input_ids=__UpperCAmelCase					)
    __lowerCamelCase    				=     result.last_hidden_state
    __lowerCamelCase    				=     result.past_key_values
    __lowerCamelCase    				=     result.encoder_last_hidden_state

    self.parent.assertEqual(encoder_output.size()						,					(self.batch_size, self.encoder_seq_length, self.hidden_size)					)
    self.parent.assertEqual(decoder_output.size()						,					(self.batch_size, self.decoder_seq_length, self.hidden_size)					)
    # There should be `num_layers` key value embeddings stored in decoder_past
    self.parent.assertEqual(len(__UpperCAmelCase					)						,					config.num_layers					)
    # There should be a self attn key, a self attn value, a cross attn key and a cross attn value stored in each decoder_past tuple
    self.parent.assertEqual(len(decoder_past[0]					)						,					4					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					):



    '''simple docstring'''
    __lowerCamelCase    				=     UMTaModel(config=__UpperCAmelCase					).get_decoder().to(__UpperCAmelCase					).eval()
    # first forward pass
    __lowerCamelCase    				=     model(__UpperCAmelCase						,					use_cache=__UpperCAmelCase					)
    __lowerCamelCase    				=     model(__UpperCAmelCase					)
    __lowerCamelCase    				=     model(__UpperCAmelCase						,					use_cache=__UpperCAmelCase					)

    self.parent.assertTrue(len(__UpperCAmelCase					) == len(__UpperCAmelCase					)					)
    self.parent.assertTrue(len(__UpperCAmelCase					) == len(__UpperCAmelCase					) + 1					)

    __lowerCamelCase				,__lowerCamelCase    				=     outputs.to_tuple()

    # create hypothetical next token and extent to next_input_ids
    __lowerCamelCase    				=     ids_tensor((self.batch_size, 1)						,					config.vocab_size					)

    # append to next input_ids and
    __lowerCamelCase    				=     torch.cat([input_ids, next_tokens]						,					dim=-1					)

    __lowerCamelCase    				=     model(__UpperCAmelCase					)['''last_hidden_state''']
    __lowerCamelCase    				=     model(__UpperCAmelCase						,					past_key_values=__UpperCAmelCase					)['''last_hidden_state''']

    # select random slice
    __lowerCamelCase    				=     ids_tensor((1,)						,					output_from_past.shape[-1]					).item()
    __lowerCamelCase    				=     output_from_no_past[:, -1, random_slice_idx].detach()
    __lowerCamelCase    				=     output_from_past[:, 0, random_slice_idx].detach()

    # test that outputs are equal for slice
    self.parent.assertTrue(torch.allclose(__UpperCAmelCase						,					__UpperCAmelCase						,					atol=1E-3					)					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					):



    '''simple docstring'''
    __lowerCamelCase    				=     UMTaModel(config=__UpperCAmelCase					).to(__UpperCAmelCase					).half().eval()
    __lowerCamelCase    				=     model(**__UpperCAmelCase					)['''last_hidden_state''']
    self.parent.assertFalse(torch.isnan(__UpperCAmelCase					).any().item()					)



@require_torch
class 			__lowerCAmelCase  (						lowerCAmelCase__	,						lowerCAmelCase__	,						lowerCAmelCase__	,						unittest.TestCase ):
 lowerCAmelCase__							       =	(
     (UMTaModel, UMTaForConditionalGeneration, UMTaForQuestionAnswering) if is_torch_available() else ()
 )
 lowerCAmelCase__							       =	(UMTaForConditionalGeneration,) if is_torch_available() else ()
 lowerCAmelCase__							       =	(
     {
         """conversational""": UMTaForConditionalGeneration,
         """feature-extraction""": UMTaModel,
         """summarization""": UMTaForConditionalGeneration,
         """text2text-generation""": UMTaForConditionalGeneration,
         """translation""": UMTaForConditionalGeneration,
         """question-answering""": UMTaForQuestionAnswering,
     }
     if is_torch_available()
     else {}
 )
 lowerCAmelCase__							       =	True
 lowerCAmelCase__							       =	False
 lowerCAmelCase__							       =	False
 lowerCAmelCase__							       =	True
 lowerCAmelCase__							       =	True
 # The small UMT5 model needs higher percentages for CPU/MP tests
 lowerCAmelCase__							       =	[0.8, 0.9]




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     UMTaModelTester(self					)




 @unittest.skip('''Test has a segmentation fault on torch 1.8.0'''					)
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    __lowerCamelCase    				=     UMTaModel(config_and_inputs[0]					).to(__UpperCAmelCase					)
    with tempfile.TemporaryDirectory() as tmpdirname:
       torch.onnx.export(
           __UpperCAmelCase						,					(config_and_inputs[1], config_and_inputs[3], config_and_inputs[2])						,					F"""{tmpdirname}/t5_test.onnx"""						,					export_params=__UpperCAmelCase						,					opset_version=9						,					input_names=['''input_ids''', '''decoder_input_ids''']						,					)




 @unittest.skipIf(torch_device == '''cpu'''						,					'''Cant do half precision'''					)
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model_fpaa_forward(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     ['''encoder_attentions''', '''decoder_attentions''', '''cross_attentions''']
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    __lowerCamelCase    				=     config_and_inputs[0]
    __lowerCamelCase    				=     UMTaForConditionalGeneration(__UpperCAmelCase					).eval()
    model.to(__UpperCAmelCase					)

    __lowerCamelCase    				=     {
        '''head_mask''': torch.zeros(config.num_layers						,					config.num_heads						,					device=__UpperCAmelCase					),
        '''decoder_head_mask''': torch.zeros(config.num_decoder_layers						,					config.num_heads						,					device=__UpperCAmelCase					),
        '''cross_attn_head_mask''': torch.zeros(config.num_decoder_layers						,					config.num_heads						,					device=__UpperCAmelCase					),
    }

    for attn_name, (name, mask) in zip(__UpperCAmelCase						,					head_masking.items()					):
       __lowerCamelCase    				=     {name: mask}
       # Explicitly pass decoder_head_mask as it is required from T5 model when head_mask specified
       if name == "head_mask":
          __lowerCamelCase    				=     torch.ones(
              config.num_decoder_layers						,					config.num_heads						,					device=__UpperCAmelCase					)

       __lowerCamelCase    				=     model.generate(
           config_and_inputs[1]['''input_ids''']						,					num_beams=1						,					max_length=3						,					output_attentions=__UpperCAmelCase						,					return_dict_in_generate=__UpperCAmelCase						,					**__UpperCAmelCase						,					)
       # We check the state of decoder_attentions and cross_attentions just from the last step
       __lowerCamelCase    				=     out[attn_name] if attn_name == attention_names[0] else out[attn_name][-1]
       self.assertEqual(sum([w.sum().item() for w in attn_weights]					)						,					0.0					)




 @unittest.skip('''Does not work on the tiny model as we keep hitting edge cases.'''					)
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    pass



@require_torch
@require_sentencepiece
@require_tokenizers
class 			__lowerCAmelCase  (						unittest.TestCase ):




 @slow
 @unittest.skip(
     '''Unless we stop stripping left and right by default for all special tokens, the expected ids obtained here will not match the original ones. Wait for https://github.com/huggingface/transformers/pull/23909 to be merged'''					)
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     UMTaForConditionalGeneration.from_pretrained('''google/umt5-small'''						,					return_dict=__UpperCAmelCase					).to(__UpperCAmelCase					)
    __lowerCamelCase    				=     AutoTokenizer.from_pretrained('''google/umt5-small'''						,					use_fast=__UpperCAmelCase						,					legacy=__UpperCAmelCase					)
    __lowerCamelCase    				=     [
        '''Bonjour monsieur <extra_id_0> bien <extra_id_1>.''',
        '''No se como puedo <extra_id_0>.''',
        '''This is the reason why we <extra_id_0> them.''',
        '''The <extra_id_0> walks in <extra_id_1>, seats''',
        '''A <extra_id_0> walks into a bar and orders a <extra_id_1> with <extra_id_2> pinch of <extra_id_3>.''',
    ]
    __lowerCamelCase    				=     tokenizer(__UpperCAmelCase						,					return_tensors='''pt'''						,					padding=__UpperCAmelCase					).input_ids
    # fmt: off
    __lowerCamelCase    				=     torch.tensor(
        [
            [ 38530, 210703, 256299, 1410, 256298, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
            [   826, 321, 671, 25922, 256299, 274, 1, 0,0, 0, 0, 0, 0, 0, 0, 0,0, 0],
            [  1460, 339, 312, 19014, 10620, 758, 256299, 2355,274, 1, 0, 0, 0, 0, 0, 0,0, 0],
            [   517, 256299, 14869, 281, 301, 256298, 275, 119983,1, 0, 0, 0, 0, 0, 0, 0,0, 0],
            [   320, 256299, 14869, 281, 2234, 289, 2275, 333,61391, 289, 256298, 543, 256297, 168714, 329, 256296,274, 1],
        ]					)
    # fmt: on
    torch.testing.assert_allclose(__UpperCAmelCase						,					__UpperCAmelCase					)

    __lowerCamelCase    				=     model.generate(input_ids.to(__UpperCAmelCase					)					)
    __lowerCamelCase    				=     [
        '''<pad><extra_id_0> et<extra_id_1> [eod] <extra_id_2><extra_id_55>.. [eod] 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 💐 <extra_id_56>ajšietosto<extra_id_56>lleux<extra_id_19><extra_id_6>ajšie</s>''',
        '''<pad><extra_id_0>.<extra_id_1>.,<0x0A>...spech <0x0A><extra_id_20> <extra_id_21></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
        '''<pad><extra_id_0> are not going to be a part of the world. We are not going to be a part of<extra_id_1> and<extra_id_2><0x0A><extra_id_48>.<extra_id_48></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
        '''<pad><extra_id_0> door<extra_id_1>, the door<extra_id_2> 피해[/</s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
        '''<pad><extra_id_0>nyone who<extra_id_1> drink<extra_id_2> a<extra_id_3> alcohol<extra_id_4> A<extra_id_5> A. This<extra_id_6> I<extra_id_7><extra_id_52><extra_id_53></s><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad><pad>''',
    ]
    __lowerCamelCase    				=     tokenizer.batch_decode(__UpperCAmelCase					)
    self.assertEqual(__UpperCAmelCase						,					__UpperCAmelCase					)






