
'''simple docstring'''

import os

import pytest
import yaml

from datasets.features.features import Features, Value
from datasets.info import DatasetInfo, DatasetInfosDict







@pytest.mark.parametrize(
    "files"    ,						[
        ["full:README.md", "dataset_infos.json"],
        ["empty:README.md", "dataset_infos.json"],
        ["dataset_infos.json"],
        ["full:README.md"],
    ]    ,						)
def 	A  (   UpperCamelCase_       :  Tuple    ,						UpperCamelCase_       :  Optional[Any]   )       ->							List[Any]:







			'''simple docstring'''



			lowerCAmelCase__										=				tmp_path_factory.mktemp("dset_infos_dir"   )
			if "full:README.md" in files:
						with open(dataset_infos_dir / "README.md"    ,						"w"   ) as f:
									f.write("---\ndataset_info:\n  dataset_size: 42\n---"   )
			if "empty:README.md" in files:
						with open(dataset_infos_dir / "README.md"    ,						"w"   ) as f:
									f.write(""   )
    # we want to support dataset_infos.json for backward compatibility
			if "dataset_infos.json" in files:
						with open(dataset_infos_dir / "dataset_infos.json"    ,						"w"   ) as f:
									f.write("{\"default\": {\"dataset_size\": 42}}"   )
			lowerCAmelCase__										=				DatasetInfosDict.from_directory(UpperCamelCase_   )
			assert dataset_infos
			assert dataset_infos["default"].dataset_size == 42







@pytest.mark.parametrize(
    "dataset_info"    ,						[
        DatasetInfo(),
        DatasetInfo(
            description="foo"    ,						features=Features({"a": Value("int32"   )}   )    ,						builder_name="builder"    ,						config_name="config"    ,						version="1.0.0"    ,						splits=[{"name": "train"}]    ,						download_size=42    ,						),
    ]    ,						)
def 	A  (   UpperCamelCase_       :  Optional[Any]    ,						UpperCamelCase_       :  DatasetInfo   )       ->							Optional[int]:







			'''simple docstring'''



			lowerCAmelCase__										=				str(UpperCamelCase_   )
			dataset_info.write_to_directory(UpperCamelCase_   )
			lowerCAmelCase__										=				DatasetInfo.from_directory(UpperCamelCase_   )
			assert dataset_info == reloaded
			assert os.path.exists(os.path.join(UpperCamelCase_    ,						"dataset_info.json"   )   )







def 	A  (   )       ->							List[Any]:







			'''simple docstring'''



			lowerCAmelCase__										=				DatasetInfo(
			    description="foo"    ,						citation="bar"    ,						homepage="https://foo.bar"    ,						license="CC0"    ,						features=Features({"a": Value("int32"   )}   )    ,						post_processed={}    ,						supervised_keys=()    ,						task_templates=[]    ,						builder_name="builder"    ,						config_name="config"    ,						version="1.0.0"    ,						splits=[{"name": "train", "num_examples": 42}]    ,						download_checksums={}    ,						download_size=13_37    ,						post_processing_size=4_42    ,						dataset_size=12_34    ,						size_in_bytes=13_37 + 4_42 + 12_34    ,						)
			lowerCAmelCase__										=				dataset_info._to_yaml_dict()
			assert sorted(UpperCamelCase_   ) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML   )
			for key in DatasetInfo._INCLUDED_INFO_IN_YAML:
						assert key in dataset_info_yaml_dict
						assert isinstance(dataset_info_yaml_dict[key]    ,						(list, dict, int, str)   )
			lowerCAmelCase__										=				yaml.safe_dump(UpperCamelCase_   )
			lowerCAmelCase__										=				yaml.safe_load(UpperCamelCase_   )
			assert dataset_info_yaml_dict == reloaded







def 	A  (   )       ->							str:







			'''simple docstring'''



			lowerCAmelCase__										=				DatasetInfo()
			lowerCAmelCase__										=				dataset_info._to_yaml_dict()
			assert dataset_info_yaml_dict == {}







@pytest.mark.parametrize(
    "dataset_infos_dict"    ,						[
        DatasetInfosDict(),
        DatasetInfosDict({"default": DatasetInfo()}   ),
        DatasetInfosDict({"my_config_name": DatasetInfo()}   ),
        DatasetInfosDict(
            {
                "default": DatasetInfo(
                    description="foo"    ,						features=Features({"a": Value("int32"   )}   )    ,						builder_name="builder"    ,						config_name="config"    ,						version="1.0.0"    ,						splits=[{"name": "train"}]    ,						download_size=42    ,						)
            }   ),
        DatasetInfosDict(
            {
                "v1": DatasetInfo(dataset_size=42   ),
                "v2": DatasetInfo(dataset_size=13_37   ),
            }   ),
    ]    ,						)
def 	A  (   UpperCamelCase_       :  Dict    ,						UpperCamelCase_       :  DatasetInfosDict   )       ->							Union[str, Any]:







			'''simple docstring'''



			lowerCAmelCase__										=				str(UpperCamelCase_   )
			dataset_infos_dict.write_to_directory(UpperCamelCase_   )
			lowerCAmelCase__										=				DatasetInfosDict.from_directory(UpperCamelCase_   )

			# the config_name of the dataset_infos_dict take over the attribute
			for config_name, dataset_info in dataset_infos_dict.items():
						lowerCAmelCase__										=				config_name
						# the yaml representation doesn't include fields like description or citation
						# so we just test that we can recover what we can from the yaml
						lowerCAmelCase__										=				DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict()   )
			assert dataset_infos_dict == reloaded

			if dataset_infos_dict:
						assert os.path.exists(os.path.join(UpperCamelCase_    ,						"README.md"   )   )








import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

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


if is_torch_available():
	import torch

	from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM



@require_torch
class        A__:
						"""simple docstring"""






						def __init__(    self  ,      _lowercase  ,      _lowercase=99  ,      _lowercase=13  ,      _lowercase=16  ,      _lowercase=7  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=True  ,      _lowercase=False  ,      _lowercase=True  ,      _lowercase=2  ,      _lowercase=32  ,      _lowercase=4  ,      _lowercase=4  ,      _lowercase=30  ,      _lowercase=0  ,      _lowercase=1  ,      _lowercase=2  ,      _lowercase=None  ,      )     -> List[str]:
									a_						:						Union[str, Any] 							= parent
									a_						:						Dict 							= batch_size
									a_						:						Any 							= decoder_seq_length
									# For common tests
									a_						:						Any 							= self.decoder_seq_length
									a_						:						int 							= is_training
									a_						:						List[Any] 							= use_attention_mask
									a_						:						List[str] 							= use_labels

									a_						:						Optional[Any] 							= vocab_size
									a_						:						Dict 							= d_model
									a_						:						Any 							= d_model
									a_						:						List[Any] 							= decoder_layers
									a_						:						List[str] 							= decoder_layers
									a_						:						Union[str, Any] 							= decoder_ffn_dim
									a_						:						Optional[Any] 							= decoder_attention_heads
									a_						:						Optional[Any] 							= decoder_attention_heads
									a_						:						Tuple 							= eos_token_id
									a_						:						Union[str, Any] 							= bos_token_id
									a_						:						Dict 							= pad_token_id
									a_						:						Union[str, Any] 							= decoder_start_token_id
									a_						:						List[Any] 							= use_cache
									a_						:						List[str] 							= max_position_embeddings

									a_						:						int 							= None
									a_						:						Any 							= decoder_seq_length
									a_						:						Union[str, Any] 							= 2
									a_						:						Optional[int] 							= 1





						def 			UpperCamelCase__					(    self    )     -> int:
									a_						:						Optional[int] 							= ids_tensor([self.batch_size, self.decoder_seq_length]  ,      self.vocab_size    )

									a_						:						Optional[int] 							= None
									if self.use_attention_mask:
												a_						:						List[Any] 							= ids_tensor([self.batch_size, self.decoder_seq_length]  ,      vocab_size=2    )

									a_						:						List[Any] 							= None
									if self.use_labels:
												a_						:						Union[str, Any] 							= ids_tensor([self.batch_size, self.decoder_seq_length]  ,      self.vocab_size    )

									a_						:						Any 							= TrOCRConfig(
									    vocab_size=self.vocab_size  ,      d_model=self.d_model  ,      decoder_layers=self.decoder_layers  ,      decoder_ffn_dim=self.decoder_ffn_dim  ,      decoder_attention_heads=self.decoder_attention_heads  ,      eos_token_id=self.eos_token_id  ,      bos_token_id=self.bos_token_id  ,      use_cache=self.use_cache  ,      pad_token_id=self.pad_token_id  ,      decoder_start_token_id=self.decoder_start_token_id  ,      max_position_embeddings=self.max_position_embeddings  ,      )

									return (config, input_ids, attention_mask, lm_labels)





						def 			UpperCamelCase__					(    self  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      _lowercase  ,      )     -> List[Any]:
									a_						:						Optional[int] 							= True
									a_						:						List[str] 							= TrOCRDecoder(config=_lowercase    ).to(_lowercase    ).eval()
									a_						:						str 							= input_ids[:2]

									input_ids[input_ids == 0] += 1
									# first forward pass
									a_						:						Dict 							= model(_lowercase  ,      use_cache=_lowercase    )
									a_						:						Union[str, Any] 							= model(_lowercase    )
									a_						:						Union[str, Any] 							= model(_lowercase  ,      use_cache=_lowercase    )

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

									a_						:						Dict 							= outputs["""past_key_values"""]

									# create hypothetical next token and extent to next_input_ids
									a_						:						List[str] 							= ids_tensor((2, 1)  ,      config.vocab_size - 1    ) + 1

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

									a_						:						Dict 							= model(_lowercase    )["""last_hidden_state"""]
									a_						:						List[str] 							= model(_lowercase  ,      past_key_values=_lowercase    )["""last_hidden_state"""]

									# select random slice
									a_						:						Optional[Any] 							= ids_tensor((1,)  ,      output_from_past.shape[-1]    ).item()
									a_						:						Union[str, Any] 							= output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
									a_						:						Any 							= output_from_past[:, 0, random_slice_idx].detach()

									# test that outputs are equal for slice
									assert torch.allclose(_lowercase  ,      _lowercase  ,      atol=1e-3    )





						def 			UpperCamelCase__					(    self    )     -> Optional[Any]:
									a_						:						List[Any] 							= self.prepare_config_and_inputs()
									a_							,					a_							,					a_							,					a_						:						List[Any] 							= config_and_inputs

									a_						:						str 							= {"""input_ids""": input_ids, """attention_mask""": attention_mask}
									return config, inputs_dict







@require_torch
class        A__(a_,  a_,  a_,  unittest.TestCase							):
						"""simple docstring"""






						_A    :				Optional[Any]       					=			(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
						_A    :				Optional[int]       					=			(TrOCRForCausalLM,) if is_torch_available() else ()
						_A    :				Tuple       					=			{'''text-generation''': TrOCRForCausalLM} if is_torch_available() else {}
						_A    :				List[str]       					=			True
						_A    :				List[str]       					=			False





						def 			UpperCamelCase__					(    self    )     -> List[Any]:
									a_						:						str 							= TrOCRStandaloneDecoderModelTester(self  ,      is_training=_lowercase    )
									a_						:						str 							= ConfigTester(self  ,      config_class=_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> Tuple:
									pass





						def 			UpperCamelCase__					(    self    )     -> int:
									pass





						def 			UpperCamelCase__					(    self    )     -> str:
									pass





						def 			UpperCamelCase__					(    self    )     -> Dict:
									self.config_tester.run_common_tests()





						def 			UpperCamelCase__					(    self    )     -> List[str]:
									a_						:						int 							= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_decoder_model_past(*_lowercase    )





						def 			UpperCamelCase__					(    self    )     -> Tuple:
									return





						@unittest.skip("""The model doesn't support left padding"""    )  # and it's not used enough to be worth fixing :)
						def 			UpperCamelCase__					(    self    )     -> Optional[Any]:
									pass


