



import unittest

from parameterized import parameterized

from transformers import LlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
 import torch

 from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer

class 					_A :



       def __init__(	self							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  List[str]=13  ,	__SCREAMING_SNAKE_CASE							:  List[str]=7  ,	__SCREAMING_SNAKE_CASE							:  Tuple=True  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]=True  ,	__SCREAMING_SNAKE_CASE							:  List[Any]=False  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]=True  ,	__SCREAMING_SNAKE_CASE							:  Tuple=99  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any]=32  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]=5  ,	__SCREAMING_SNAKE_CASE							:  List[str]=4  ,	__SCREAMING_SNAKE_CASE							:  str=37  ,	__SCREAMING_SNAKE_CASE							:  str="gelu"  ,	__SCREAMING_SNAKE_CASE							:  Any=0.1  ,	__SCREAMING_SNAKE_CASE							:  Tuple=0.1  ,	__SCREAMING_SNAKE_CASE							:  int=512  ,	__SCREAMING_SNAKE_CASE							:  Dict=16  ,	__SCREAMING_SNAKE_CASE							:  int=2  ,	__SCREAMING_SNAKE_CASE							:  str=0.02  ,	__SCREAMING_SNAKE_CASE							:  int=3  ,	__SCREAMING_SNAKE_CASE							:  Optional[int]=4  ,	__SCREAMING_SNAKE_CASE							:  List[str]=None  ,	):


           '''simple docstring'''

           __a		 =       parent
           __a		 =       batch_size
           __a		 =       seq_length
           __a		 =       is_training
           __a		 =       use_input_mask
           __a		 =       use_token_type_ids
           __a		 =       use_labels
           __a		 =       vocab_size
           __a		 =       hidden_size
           __a		 =       num_hidden_layers
           __a		 =       num_attention_heads
           __a		 =       intermediate_size
           __a		 =       hidden_act
           __a		 =       hidden_dropout_prob
           __a		 =       attention_probs_dropout_prob
           __a		 =       max_position_embeddings
           __a		 =       type_vocab_size
           __a		 =       type_sequence_label_size
           __a		 =       initializer_range
           __a		 =       num_labels
           __a		 =       num_choices
           __a		 =       scope



       def 	_lowerCamelCase    (	self							:  List[Any]):


           '''simple docstring'''

           __a		 =       ids_tensor([self.batch_size, self.seq_length]  ,	self.vocab_size)

           __a		 =       None
           if self.use_input_mask:
               __a		 =       random_attention_mask([self.batch_size, self.seq_length])

           __a		 =       None
           if self.use_token_type_ids:
               __a		 =       ids_tensor([self.batch_size, self.seq_length]  ,	self.type_vocab_size)

           __a		 =       None
           __a		 =       None
           __a		 =       None
           if self.use_labels:
               __a		 =       ids_tensor([self.batch_size]  ,	self.type_sequence_label_size)
               __a		 =       ids_tensor([self.batch_size, self.seq_length]  ,	self.num_labels)
               __a		 =       ids_tensor([self.batch_size]  ,	self.num_choices)

           __a		 =       self.get_config()

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



       def 	_lowerCamelCase    (	self							:  Optional[int]):


           '''simple docstring'''

           return LlamaConfig(
               vocab_size=self.vocab_size  ,	hidden_size=self.hidden_size  ,	num_hidden_layers=self.num_hidden_layers  ,	num_attention_heads=self.num_attention_heads  ,	intermediate_size=self.intermediate_size  ,	hidden_act=self.hidden_act  ,	hidden_dropout_prob=self.hidden_dropout_prob  ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,	max_position_embeddings=self.max_position_embeddings  ,	type_vocab_size=self.type_vocab_size  ,	is_decoder=_a  ,	initializer_range=self.initializer_range  ,	)



       def 	_lowerCamelCase    (	self							:  str  ,	__SCREAMING_SNAKE_CASE							:  Tuple  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  Optional[int]  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  Tuple):


           '''simple docstring'''

           __a		 =       LlamaModel(config=_a)
           model.to(_a)
           model.eval()
           __a		 =       model(_a  ,	attention_mask=_a)
           __a		 =       model(_a)
           self.parent.assertEqual(result.last_hidden_state.shape  ,	(self.batch_size, self.seq_length, self.hidden_size))



       def 	_lowerCamelCase    (	self							:  Optional[int]  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any]  ,	__SCREAMING_SNAKE_CASE							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  List[str]  ,	__SCREAMING_SNAKE_CASE							:  int  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]  ,	):


           '''simple docstring'''

           __a		 =       True
           __a		 =       LlamaModel(_a)
           model.to(_a)
           model.eval()
           __a		 =       model(
               _a  ,	attention_mask=_a  ,	encoder_hidden_states=_a  ,	encoder_attention_mask=_a  ,	)
           __a		 =       model(
               _a  ,	attention_mask=_a  ,	encoder_hidden_states=_a  ,	)
           __a		 =       model(_a  ,	attention_mask=_a)
           self.parent.assertEqual(result.last_hidden_state.shape  ,	(self.batch_size, self.seq_length, self.hidden_size))



       def 	_lowerCamelCase    (	self							:  Any  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any]  ,	__SCREAMING_SNAKE_CASE							:  List[str]  ,	__SCREAMING_SNAKE_CASE							:  int  ,	__SCREAMING_SNAKE_CASE							:  Optional[int]  ,	__SCREAMING_SNAKE_CASE							:  int  ,	__SCREAMING_SNAKE_CASE							:  int  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  int  ,	__SCREAMING_SNAKE_CASE							:  Any  ,	):


           '''simple docstring'''

           __a		 =       LlamaForCausalLM(config=_a)
           model.to(_a)
           model.eval()
           __a		 =       model(_a  ,	attention_mask=_a  ,	labels=_a)
           self.parent.assertEqual(result.logits.shape  ,	(self.batch_size, self.seq_length, self.vocab_size))



       def 	_lowerCamelCase    (	self							:  Tuple  ,	__SCREAMING_SNAKE_CASE							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  Any  ,	__SCREAMING_SNAKE_CASE							:  List[str]  ,	__SCREAMING_SNAKE_CASE							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  Tuple  ,	__SCREAMING_SNAKE_CASE							:  Tuple  ,	__SCREAMING_SNAKE_CASE							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  List[str]  ,	):


           '''simple docstring'''

           __a		 =       True
           __a		 =       True
           __a		 =       LlamaForCausalLM(config=_a)
           model.to(_a)
           model.eval()

           # first forward pass
           __a		 =       model(
               _a  ,	attention_mask=_a  ,	encoder_hidden_states=_a  ,	encoder_attention_mask=_a  ,	use_cache=_a  ,	)
           __a		 =       outputs.past_key_values

           # create hypothetical multiple next token and extent to next_input_ids
           __a		 =       ids_tensor((self.batch_size, 3)  ,	config.vocab_size)
           __a		 =       ids_tensor((self.batch_size, 3)  ,	vocab_size=2)

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

           __a		 =       model(
               _a  ,	attention_mask=_a  ,	encoder_hidden_states=_a  ,	encoder_attention_mask=_a  ,	output_hidden_states=_a  ,	)["""hidden_states"""][0]
           __a		 =       model(
               _a  ,	attention_mask=_a  ,	encoder_hidden_states=_a  ,	encoder_attention_mask=_a  ,	past_key_values=_a  ,	output_hidden_states=_a  ,	)["""hidden_states"""][0]

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

           self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1])

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





       def 	_lowerCamelCase    (	self							:  Union[str, Any]):


           '''simple docstring'''

           __a		 =       self.prepare_config_and_inputs()
           (
               __a     
           )		 =       config_and_inputs
           __a		 =       {"""input_ids""": input_ids, """attention_mask""": input_mask}
           return config, inputs_dict


@require_torch
class 					_A (			UpperCamelCase__   ,UpperCamelCase__   ,UpperCamelCase__   ,unittest.TestCase					):
       UpperCamelCase__						:					Union[str, Any]		      =		(LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
       UpperCamelCase__						:					List[str]		      =		(LlamaForCausalLM,) if is_torch_available() else ()
       UpperCamelCase__						:					Optional[int]		      =		(
           {
               '''feature-extraction''': LlamaModel,
               '''text-classification''': LlamaForSequenceClassification,
               '''text-generation''': LlamaForCausalLM,
               '''zero-shot''': LlamaForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       UpperCamelCase__						:					List[Any]		      =		False
       UpperCamelCase__						:					Dict		      =		False



       def 	_lowerCamelCase    (	self							:  Dict):


           '''simple docstring'''

           __a		 =       LlamaModelTester(self)
           __a		 =       ConfigTester(self  ,	config_class=_a  ,	hidden_size=37)



       def 	_lowerCamelCase    (	self							:  Optional[Any]):


           '''simple docstring'''

           self.config_tester.run_common_tests()



       def 	_lowerCamelCase    (	self							:  int):


           '''simple docstring'''

           __a		 =       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*_a)



       def 	_lowerCamelCase    (	self							:  int):


           '''simple docstring'''

           __a		 =       self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
               __a		 =       type
               self.model_tester.create_and_check_model(*_a)



       def 	_lowerCamelCase    (	self							:  Any):


           '''simple docstring'''

           __a		 =       self.model_tester.prepare_config_and_inputs_for_common()
           __a		 =       3
           __a		 =       input_dict["""input_ids"""]
           __a		 =       input_ids.ne(1).to(_a)
           __a		 =       ids_tensor([self.model_tester.batch_size]  ,	self.model_tester.type_sequence_label_size)
           __a		 =       LlamaForSequenceClassification(_a)
           model.to(_a)
           model.eval()
           __a		 =       model(_a  ,	attention_mask=_a  ,	labels=_a)
           self.assertEqual(result.logits.shape  ,	(self.model_tester.batch_size, self.model_tester.num_labels))



       def 	_lowerCamelCase    (	self							:  List[Any]):


           '''simple docstring'''

           __a		 =       self.model_tester.prepare_config_and_inputs_for_common()
           __a		 =       3
           __a		 =       """single_label_classification"""
           __a		 =       input_dict["""input_ids"""]
           __a		 =       input_ids.ne(1).to(_a)
           __a		 =       ids_tensor([self.model_tester.batch_size]  ,	self.model_tester.type_sequence_label_size)
           __a		 =       LlamaForSequenceClassification(_a)
           model.to(_a)
           model.eval()
           __a		 =       model(_a  ,	attention_mask=_a  ,	labels=_a)
           self.assertEqual(result.logits.shape  ,	(self.model_tester.batch_size, self.model_tester.num_labels))



       def 	_lowerCamelCase    (	self							:  List[Any]):


           '''simple docstring'''

           __a		 =       self.model_tester.prepare_config_and_inputs_for_common()
           __a		 =       3
           __a		 =       """multi_label_classification"""
           __a		 =       input_dict["""input_ids"""]
           __a		 =       input_ids.ne(1).to(_a)
           __a		 =       ids_tensor(
               [self.model_tester.batch_size, config.num_labels]  ,	self.model_tester.type_sequence_label_size).to(torch.float)
           __a		 =       LlamaForSequenceClassification(_a)
           model.to(_a)
           model.eval()
           __a		 =       model(_a  ,	attention_mask=_a  ,	labels=_a)
           self.assertEqual(result.logits.shape  ,	(self.model_tester.batch_size, self.model_tester.num_labels))



       @unittest.skip('''LLaMA buffers include complex numbers, which breaks this test''')
       def 	_lowerCamelCase    (	self							:  str):


           '''simple docstring'''

           pass





       @parameterized.expand([('''linear''',), ('''dynamic''',)])
       def 	_lowerCamelCase    (	self							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  List[Any]):


           '''simple docstring'''

           __a		 =       self.model_tester.prepare_config_and_inputs_for_common()
           __a		 =       ids_tensor([1, 10]  ,	config.vocab_size)
           __a		 =       ids_tensor([1, int(config.max_position_embeddings * 1.5)]  ,	config.vocab_size)

           set_seed(42)  # Fixed seed at init time so the two models get the same random weights
           __a		 =       LlamaModel(_a)
           original_model.to(_a)
           original_model.eval()
           __a		 =       original_model(_a).last_hidden_state
           __a		 =       original_model(_a).last_hidden_state

           set_seed(42)  # Fixed seed at init time so the two models get the same random weights
           __a		 =       {"""type""": scaling_type, """factor""": 10.0}
           __a		 =       LlamaModel(_a)
           scaled_model.to(_a)
           scaled_model.eval()
           __a		 =       scaled_model(_a).last_hidden_state
           __a		 =       scaled_model(_a).last_hidden_state

           # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
           # maximum sequence length, so the outputs for the short input should match.
           if scaling_type == "dynamic":
               self.assertTrue(torch.allclose(_a  ,	_a  ,	atol=1E-5))
           else:
               self.assertFalse(torch.allclose(_a  ,	_a  ,	atol=1E-5))

           # The output should be different for long inputs
           self.assertFalse(torch.allclose(_a  ,	_a  ,	atol=1E-5))


@require_torch
class 					_A (			unittest.TestCase					):



       @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''')
       @slow
       def 	_lowerCamelCase    (	self							:  List[Any]):


           '''simple docstring'''

           __a		 =       [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           __a		 =       LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-7b-hf'''  ,	device_map='''auto''')
           __a		 =       model(torch.tensor([input_ids]))
           # Expected mean on dim = -1
           __a		 =       torch.tensor([[-6.65_50, -4.12_27, -4.98_59, -3.24_06, 0.82_62, -3.00_33, 1.29_64, -3.36_99]])
           torch.testing.assert_close(out.mean(-1)  ,	_a  ,	atol=1E-2  ,	rtol=1E-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           __a		 =       torch.tensor([-12.82_81, -7.44_53, -0.46_39, -8.06_25, -7.25_00, -8.00_00, -6.48_83, -7.76_95, -7.84_38, -7.03_12, -6.21_88, -7.13_28, -1.84_96, 1.99_61, -8.62_50, -6.72_27, -12.82_81, -6.94_92, -7.07_42, -7.78_52, -7.58_20, -7.90_62, -6.93_75, -7.98_05, -8.34_38, -8.15_62, -8.04_69, -7.62_50, -7.74_22, -7.33_98,])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30]  ,	_a  ,	atol=1E-5  ,	rtol=1E-5)



       @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''')
       @slow
       def 	_lowerCamelCase    (	self							:  Optional[int]):


           '''simple docstring'''

           __a		 =       [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           __a		 =       LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-hf'''  ,	device_map='''auto''')
           __a		 =       model(torch.tensor(_a))
           # Expected mean on dim = -1
           __a		 =       torch.tensor([[-2.06_22, -1.27_94, -1.16_38, -0.97_88, -1.46_03, -1.02_38, -1.78_93, -1.44_11]])
           torch.testing.assert_close(out.mean(-1)  ,	_a  ,	atol=1E-2  ,	rtol=1E-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           __a		 =       torch.tensor([-8.14_06, -8.05_47, 2.74_61, -1.23_44, -0.14_48, -1.82_62, -1.00_20, -1.81_54, -1.68_95, -1.85_16, -2.35_74, -0.92_77, 3.75_98, 6.57_42, -1.29_98, -0.11_77, -8.14_06, -2.96_88, -2.91_99, -3.16_99, -3.52_54, -2.35_55, -2.79_88, -3.41_41, -2.82_62, -4.51_95, -3.33_79, -3.31_64, -2.78_32, -3.02_73])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30]  ,	_a  ,	atol=1E-5  ,	rtol=1E-5)



       @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!''')
       @slow
       def 	_lowerCamelCase    (	self							:  Union[str, Any]):


           '''simple docstring'''

           __a		 =       [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           __a		 =       LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''  ,	device_map='''auto''')
           __a		 =       model(torch.tensor(_a))
           # Expected mean on dim = -1
           __a		 =       torch.tensor([[-0.85_62, -1.85_20, -0.75_51, -0.41_62, -1.51_61, -1.20_38, -2.48_23, -2.32_54]])
           torch.testing.assert_close(out.mean(-1)  ,	_a  ,	atol=1E-2  ,	rtol=1E-2)
           # slicing logits[0, 0, 0:30]
           # fmt: off
           __a		 =       torch.tensor([-2.22_27, 4.88_28, 0.90_23, -0.45_78, -0.78_71, -0.10_33, -0.62_21, -0.57_86, -0.78_03, -1.06_74, -1.29_20, -0.15_70, 0.80_08, 2.07_23, -0.94_97, 0.27_71, -2.22_27, -0.76_12, -1.43_46, -1.20_61, -1.64_26, -0.30_00, -0.71_39, -1.19_34, -1.86_91, -1.69_73, -1.59_47, -1.27_05, -0.35_23, -0.55_13])
           # fmt: on
           torch.testing.assert_close(out.mean(-1)  ,	_a  ,	atol=1E-2  ,	rtol=1E-2)



       @unittest.skip(
           '''Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test''')
       @slow
       def 	_lowerCamelCase    (	self							:  str):


           '''simple docstring'''

           __a		 =       [1, 306, 4_658, 278, 6_593, 310, 2_834, 338]
           __a		 =       LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-70b-hf'''  ,	device_map='''auto''')
           __a		 =       model(torch.tensor(_a))

           __a		 =       torch.tensor(
               [[-4.23_27, -3.33_60, -4.66_65, -4.76_31, -1.81_80, -3.41_70, -1.42_11, -3.18_10]]  ,	dtype=torch.floataa)
           torch.testing.assert_close(out.mean(-1)  ,	_a  ,	atol=1E-2  ,	rtol=1E-2)
           # fmt: off
           __a		 =       torch.tensor([-9.49_22, -3.95_51, 1.79_98, -5.67_58, -5.10_55, -5.89_84, -4.83_20, -6.80_86, -6.53_91, -5.61_72, -5.58_20, -5.53_52, 1.78_81, 3.62_89, -6.51_17, -3.47_85, -9.50_00, -6.03_52, -6.81_25, -6.01_95, -6.68_36, -5.47_27, -6.28_12, -6.03_91, -7.33_98, -7.42_97, -7.48_44, -6.58_20, -5.87_89, -5.53_12])
           # fmt: on
           torch.testing.assert_close(out[0, 0, :30]  ,	_a  ,	atol=1E-5  ,	rtol=1E-5)





       @unittest.skip('''Model is curently gated''')
       @slow
       def 	_lowerCamelCase    (	self							:  str):


           '''simple docstring'''

           __a		 =       """Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the \"princi"""
           __a		 =       """Simply put, the theory of relativity states that """
           __a		 =       LlamaTokenizer.from_pretrained('''meta-llama/Llama-2-13b-chat-hf''')
           __a		 =       tokenizer.encode(_a  ,	return_tensors='''pt''')
           __a		 =       LlamaForCausalLM.from_pretrained(
               '''meta-llama/Llama-2-13b-chat-hf'''  ,	device_map='''sequential'''  ,	use_safetensors=_a)

           # greedy generation outputs
           __a		 =       model.generate(_a  ,	max_new_tokens=64  ,	top_p=_a  ,	temperature=1  ,	do_sample=_a)
           __a		 =       tokenizer.decode(generated_ids[0]  ,	skip_special_tokens=_a)
           self.assertEqual(_a  ,	_a)










import os
import sys
import unittest


__snake_case		:Union[str, Any]   	=  os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
__snake_case		:List[str]   	=  os.path.join(git_repo_path, '''src''', '''transformers''')

__snake_case		:Any   	=  '''
{0} = None
'''

__snake_case		:Dict   	=  '''
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})
'''


__snake_case		:str   	=  '''
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
'''

class 					_A (			unittest.TestCase					):



       def 	_lowerCamelCase    (	self							:  List[Any]):


           '''simple docstring'''

           __a		 =       find_backend('''    _import_structure["models.albert"].append("AlbertTokenizerFast")''')
           self.assertIsNone(__SCREAMING_SNAKE_CASE)

           __a		 =       find_backend('''    if not is_tokenizers_available():''')
           self.assertEqual(__SCREAMING_SNAKE_CASE  ,	'''tokenizers''')

           __a		 =       find_backend('''    if not is_tensorflow_text_available():''')
           self.assertEqual(__SCREAMING_SNAKE_CASE  ,	'''tensorflow_text''')

           __a		 =       find_backend('''    if not (is_sentencepiece_available() and is_tokenizers_available()):''')
           self.assertEqual(__SCREAMING_SNAKE_CASE  ,	'''sentencepiece_and_tokenizers''')

           __a		 =       find_backend(
               '''    if not (is_sentencepiece_available() and is_tensorflow_text_available()):''')
           self.assertEqual(__SCREAMING_SNAKE_CASE  ,	'''sentencepiece_and_tensorflow_text''')

           __a		 =       find_backend(
               '''    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):''')
           self.assertEqual(__SCREAMING_SNAKE_CASE  ,	'''sentencepiece_and_tokenizers_and_vision''')



       def 	_lowerCamelCase    (	self							:  Optional[Any]):


           '''simple docstring'''

           __a		 =       read_init()
           # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
           self.assertIn('''torch'''  ,	__SCREAMING_SNAKE_CASE)
           self.assertIn('''tensorflow_text'''  ,	__SCREAMING_SNAKE_CASE)
           self.assertIn('''sentencepiece_and_tokenizers'''  ,	__SCREAMING_SNAKE_CASE)

           # Likewise, we can't assert on the exact content of a key
           self.assertIn('''BertModel'''  ,	objects['''torch'''])
           self.assertIn('''TFBertModel'''  ,	objects['''tf'''])
           self.assertIn('''FlaxBertModel'''  ,	objects['''flax'''])
           self.assertIn('''BertModel'''  ,	objects['''torch'''])
           self.assertIn('''TFBertTokenizer'''  ,	objects['''tensorflow_text'''])
           self.assertIn('''convert_slow_tokenizer'''  ,	objects['''sentencepiece_and_tokenizers'''])



       def 	_lowerCamelCase    (	self							:  Any):


           '''simple docstring'''

           __a		 =       create_dummy_object('''CONSTANT'''  ,	'''\'torch\'''')
           self.assertEqual(__SCREAMING_SNAKE_CASE  ,	'''\nCONSTANT = None\n''')

           __a		 =       create_dummy_object('''function'''  ,	'''\'torch\'''')
           self.assertEqual(
               __SCREAMING_SNAKE_CASE  ,	'''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n''')

           __a		 =       '''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')
'''
           __a		 =       create_dummy_object('''FakeClass'''  ,	'''\'torch\'''')
           self.assertEqual(__SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE)





       def 	_lowerCamelCase    (	self							:  Optional[Any]):


           '''simple docstring'''

           __a		 =       '''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])
'''
           __a		 =       create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']})
           self.assertEqual(dummy_files['''torch''']  ,	__SCREAMING_SNAKE_CASE)





