






import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import (
			    TFEfficientFormerForImageClassification,
			    TFEfficientFormerForImageClassificationWithTeacher,
			    TFEfficientFormerModel,
			)
			from transformers.models.efficientformer.modeling_tf_efficientformer import (
			    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
			)


if is_vision_available():
			from PIL import Image

			from transformers import EfficientFormerImageProcessor
class  lowerCAmelCase_       :




							def __init__(   self     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   int = 13 ,							SCREAMING_SNAKE_CASE_     :   int = 64 ,							SCREAMING_SNAKE_CASE_     :   int = 2 ,							SCREAMING_SNAKE_CASE_     :   int = 3 ,							SCREAMING_SNAKE_CASE_     :   int = 3 ,							SCREAMING_SNAKE_CASE_     :   bool = True ,							SCREAMING_SNAKE_CASE_     :   bool = True ,							SCREAMING_SNAKE_CASE_     :   int = 128 ,							SCREAMING_SNAKE_CASE_     :   Dict=[16, 32, 64, 128] ,							SCREAMING_SNAKE_CASE_     :   int = 7 ,							SCREAMING_SNAKE_CASE_     :   int = 4 ,							SCREAMING_SNAKE_CASE_     :   int = 37 ,							SCREAMING_SNAKE_CASE_     :   str = "gelu" ,							SCREAMING_SNAKE_CASE_     :   float = 0.1 ,							SCREAMING_SNAKE_CASE_     :   float = 0.1 ,							SCREAMING_SNAKE_CASE_     :   int = 10 ,							SCREAMING_SNAKE_CASE_     :   float = 0.02 ,							SCREAMING_SNAKE_CASE_     :   int = 2 ,							SCREAMING_SNAKE_CASE_     :   int = 1 ,							SCREAMING_SNAKE_CASE_     :   int = 128 ,							SCREAMING_SNAKE_CASE_     :   List[int] = [2, 2, 2, 2] ,							SCREAMING_SNAKE_CASE_     :   int = 2 ,							SCREAMING_SNAKE_CASE_     :   int = 2 ,							):
											lowerCAmelCase__      			=						parent
											lowerCAmelCase__      			=						batch_size
											lowerCAmelCase__      			=						image_size
											lowerCAmelCase__      			=						patch_size
											lowerCAmelCase__      			=						num_channels
											lowerCAmelCase__      			=						is_training
											lowerCAmelCase__      			=						use_labels
											lowerCAmelCase__      			=						hidden_size
											lowerCAmelCase__      			=						num_hidden_layers
											lowerCAmelCase__      			=						num_attention_heads
											lowerCAmelCase__      			=						intermediate_size
											lowerCAmelCase__      			=						hidden_act
											lowerCAmelCase__      			=						hidden_dropout_prob
											lowerCAmelCase__      			=						attention_probs_dropout_prob
											lowerCAmelCase__      			=						type_sequence_label_size
											lowerCAmelCase__      			=						initializer_range
											lowerCAmelCase__      			=						encoder_stride
											lowerCAmelCase__      			=						num_attention_outputs
											lowerCAmelCase__      			=						embed_dim
											lowerCAmelCase__      			=						embed_dim + 1
											lowerCAmelCase__      			=						resolution
											lowerCAmelCase__      			=						depths
											lowerCAmelCase__      			=						hidden_sizes
											lowerCAmelCase__      			=						dim
											lowerCAmelCase__      			=						mlp_expansion_ratio




							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

											lowerCAmelCase__      			=						None
											if self.use_labels:
															lowerCAmelCase__      			=						ids_tensor([self.batch_size] ,							self.type_sequence_label_size	)

											lowerCAmelCase__      			=						self.get_config()

											return config, pixel_values, labels




							def 						__snake_case					(   self     :   List[Any]	):
											return EfficientFormerConfig(
											    image_size=self.image_size ,							patch_size=self.patch_size ,							num_channels=self.num_channels ,							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 ,							is_decoder=SCREAMING_SNAKE_CASE_ ,							initializer_range=self.initializer_range ,							encoder_stride=self.encoder_stride ,							resolution=self.resolution ,							depths=self.depths ,							hidden_sizes=self.hidden_sizes ,							dim=self.dim ,							mlp_expansion_ratio=self.mlp_expansion_ratio ,							)




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   Dict	):
											lowerCAmelCase__      			=						TFEfficientFormerModel(config=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_ ,							training=SCREAMING_SNAKE_CASE_	)
											self.parent.assertEqual(result.last_hidden_state.shape ,							(self.batch_size, self.seq_length, self.hidden_size)	)




							def 						__snake_case					(   self     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   int	):
											lowerCAmelCase__      			=						self.type_sequence_label_size
											lowerCAmelCase__      			=						TFEfficientFormerForImageClassification(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_ ,							labels=SCREAMING_SNAKE_CASE_ ,							training=SCREAMING_SNAKE_CASE_	)
											self.parent.assertEqual(result.logits.shape ,							(self.batch_size, self.type_sequence_label_size)	)

											# test greyscale images
											lowerCAmelCase__      			=						1
											lowerCAmelCase__      			=						TFEfficientFormerForImageClassification(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_ ,							labels=SCREAMING_SNAKE_CASE_	)
											self.parent.assertEqual(result.logits.shape ,							(self.batch_size, self.type_sequence_label_size)	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						self.prepare_config_and_inputs()
											lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						config_and_inputs
											lowerCAmelCase__      			=						{'''pixel_values''': pixel_values}
											return config, inputs_dict



@require_tf
class  lowerCAmelCase_       (				snake_case__     ,    snake_case__     ,    unittest.TestCase					):
							UpperCamelCase_		:Optional[int]		      =    (
							    (
							        TFEfficientFormerModel,
							        TFEfficientFormerForImageClassificationWithTeacher,
							        TFEfficientFormerForImageClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							UpperCamelCase_		:Any		      =    (
							    {
							        'feature-extraction': TFEfficientFormerModel,
							        'image-classification': (
							            TFEfficientFormerForImageClassification,
							            TFEfficientFormerForImageClassificationWithTeacher,
							        ),
							    }
							    if is_tf_available()
							    else {}
							)

							UpperCamelCase_		:Optional[Any]		      =    False

							UpperCamelCase_		:Any		      =    False
							UpperCamelCase_		:Optional[int]		      =    False
							UpperCamelCase_		:Union[str, Any]		      =    False
							UpperCamelCase_		:List[Any]		      =    False




							def 						__snake_case					(   self     :   Optional[int]	):
											lowerCAmelCase__      			=						TFEfficientFormerModelTester(self	)
											lowerCAmelCase__      			=						ConfigTester(
											    self ,							config_class=SCREAMING_SNAKE_CASE_ ,							has_text_modality=SCREAMING_SNAKE_CASE_ ,							hidden_size=37	)




							def 						__snake_case					(   self     :   Tuple	):
											self.config_tester.run_common_tests()




							@unittest.skip(reason='''EfficientFormer does not use inputs_embeds'''	)
							def 						__snake_case					(   self     :   Optional[int]	):
											pass




							@unittest.skip(reason='''EfficientFormer does not support input and output embeddings'''	)
							def 						__snake_case					(   self     :   List[str]	):
											pass




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															lowerCAmelCase__      			=						inspect.signature(model.call	)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															lowerCAmelCase__      			=						[*signature.parameters.keys()]

															lowerCAmelCase__      			=						['''pixel_values''']
															self.assertListEqual(arg_names[:1] ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Optional[int]	):
											def check_hidden_states_output(SCREAMING_SNAKE_CASE_     :   Any ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   Tuple	):
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)

															lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	) ,							training=SCREAMING_SNAKE_CASE_	)
															lowerCAmelCase__      			=						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															lowerCAmelCase__      			=						getattr(
															    self.model_tester ,							'''expected_num_hidden_layers''' ,							self.model_tester.num_hidden_layers + 1	)
															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							SCREAMING_SNAKE_CASE_	)

															if hasattr(self.model_tester ,							'''encoder_seq_length'''	):
																			lowerCAmelCase__      			=						self.model_tester.encoder_seq_length
																			if hasattr(self.model_tester ,							'''chunk_length'''	) and self.model_tester.chunk_length > 1:
																							lowerCAmelCase__      			=						seq_length * self.model_tester.chunk_length
															else:
																			lowerCAmelCase__      			=						self.model_tester.seq_length

															self.assertListEqual(
															    list(hidden_states[-1].shape[-2:]	) ,							[seq_length, self.model_tester.hidden_size] ,							)

															if config.is_encoder_decoder:
																			lowerCAmelCase__      			=						outputs.decoder_hidden_states

																			self.asseretIsInstance(SCREAMING_SNAKE_CASE_ ,							(list, tuple)	)
																			self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							SCREAMING_SNAKE_CASE_	)
																			lowerCAmelCase__      			=						getattr(self.model_tester ,							'''seq_length''' ,							SCREAMING_SNAKE_CASE_	)
																			lowerCAmelCase__      			=						getattr(self.model_tester ,							'''decoder_seq_length''' ,							SCREAMING_SNAKE_CASE_	)

																			self.assertListEqual(
																			    list(hidden_states[-1].shape[-2:]	) ,							[decoder_seq_length, self.model_tester.hidden_size] ,							)

											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															lowerCAmelCase__      			=						True
															check_hidden_states_output(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															lowerCAmelCase__      			=						True

															check_hidden_states_output(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   List[Any]=False	):
											lowerCAmelCase__      			=						super()._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							return_labels=SCREAMING_SNAKE_CASE_	)

											if return_labels:
															if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
																			del inputs_dict["labels"]

											return inputs_dict




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)




							@unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet'''	)
							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_	)




							@slow
							def 						__snake_case					(   self     :   str	):
											for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowerCAmelCase__      			=						TFEfficientFormerModel.from_pretrained(SCREAMING_SNAKE_CASE_	)
															self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()
											lowerCAmelCase__      			=						True

											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''seq_length''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''encoder_seq_length''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''key_length''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''chunk_length''' ,							SCREAMING_SNAKE_CASE_	)

											if chunk_length is not None and hasattr(self.model_tester ,							'''num_hashes'''	):
															lowerCAmelCase__      			=						encoder_seq_length * self.model_tester.num_hashes

											for model_class in self.all_model_classes:
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						False
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)

															lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	) ,							training=SCREAMING_SNAKE_CASE_	)
															lowerCAmelCase__      			=						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							self.model_tester.num_attention_outputs	)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															lowerCAmelCase__      			=						True
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	) ,							training=SCREAMING_SNAKE_CASE_	)

															lowerCAmelCase__      			=						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							self.model_tester.num_attention_outputs	)

															if chunk_length is not None:
																			self.assertListEqual(
																			    list(attentions[0].shape[-4:]	) ,							[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length] ,							)
															else:
																			self.assertListEqual(
																			    list(attentions[0].shape[-3:]	) ,							[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length] ,							)




							def 						__snake_case					(   self     :   List[Any]	):
											# We use a simplified version of this test for EfficientFormer because it requires training=False
											# and Keras refuses to let us force that during functional construction
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															# Prepare our model
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
															# These are maximally general inputs for the model, with multiple None dimensions
															# Hopefully this will catch any conditionals that fail for flexible shapes
															lowerCAmelCase__      			=						{
															    key: tf.keras.Input(shape=val.shape[1:] ,							dtype=val.dtype ,							name=SCREAMING_SNAKE_CASE_	)
															    for key, val in model.input_signature.items()
															    if key in model.dummy_inputs
															}
															lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)
															self.assertTrue(outputs_dict is not None	)





def 	lowerCAmelCase_		()		->    Tuple:


				'''simple docstring'''




				lowerCAmelCase__      			=						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
				return image




@require_tf
@require_vision
class  lowerCAmelCase_       (				unittest.TestCase					):




							@cached_property
							def 						__snake_case					(   self     :   str	):
											return (
											    EfficientFormerImageProcessor.from_pretrained('''snap-research/efficientformer-l1-300'''	)
											    if is_vision_available()
											    else None
											)




							@slow
							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''	)
											lowerCAmelCase__      			=						self.default_image_processor
											lowerCAmelCase__      			=						prepare_img()
											lowerCAmelCase__      			=						image_processor(images=SCREAMING_SNAKE_CASE_ ,							return_tensors='''tf'''	)
											# forward pass
											lowerCAmelCase__      			=						model(**SCREAMING_SNAKE_CASE_ ,							training=SCREAMING_SNAKE_CASE_	)
											# verify the logits
											lowerCAmelCase__      			=						tf.TensorShape((1, 1_000)	)
											self.assertEqual(outputs.logits.shape ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						tf.constant([-0.0_555, 0.4_825, -0.0_852]	)
											self.assertTrue(np.allclose(outputs.logits[0, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=1e-4	)	)




							@slow
							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
											    '''snap-research/efficientformer-l1-300'''	)
											lowerCAmelCase__      			=						self.default_image_processor
											lowerCAmelCase__      			=						prepare_img()
											lowerCAmelCase__      			=						image_processor(images=SCREAMING_SNAKE_CASE_ ,							return_tensors='''tf'''	)
											# forward pass
											lowerCAmelCase__      			=						model(**SCREAMING_SNAKE_CASE_ ,							training=SCREAMING_SNAKE_CASE_	)
											# verify the logits
											lowerCAmelCase__      			=						tf.TensorShape((1, 1_000)	)
											self.assertEqual(outputs.logits.shape ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						tf.constant([-0.1_312, 0.4_353, -1.0_499]	)
											self.assertTrue(np.allclose(outputs.logits[0, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=1e-4	)	)













import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


_UpperCAmelCase			:		List[Any]   				=    logging.getLogger()
@unittest.skip('Temporarily disable the doc tests.'					)
@require_torch
@require_tf
@slow
class  lowerCAmelCase_       (				unittest.TestCase					):




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Path ,							SCREAMING_SNAKE_CASE_     :   Union[str, None] = None ,							SCREAMING_SNAKE_CASE_     :   Union[List[str], None] = None ,							SCREAMING_SNAKE_CASE_     :   Union[str, List[str], None] = None ,							SCREAMING_SNAKE_CASE_     :   bool = True ,							):
											lowerCAmelCase__      			=						[file for file in os.listdir(SCREAMING_SNAKE_CASE_	) if os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)	)]

											if identifier is not None:
															lowerCAmelCase__      			=						[file for file in files if identifier in file]

											if n_identifier is not None:
															if isinstance(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	):
																			for n_ in n_identifier:
																							lowerCAmelCase__      			=						[file for file in files if n_ not in file]
															else:
																			lowerCAmelCase__      			=						[file for file in files if n_identifier not in file]

											lowerCAmelCase__      			=						ignore_files or []
											ignore_files.append('''__init__.py'''	)
											lowerCAmelCase__      			=						[file for file in files if file not in ignore_files]

											for file in files:
															# Open all files
															print('''Testing''' ,							SCREAMING_SNAKE_CASE_	)

															if only_modules:
																			lowerCAmelCase__      			=						file.split('''.'''	)[0]
																			try:
																							lowerCAmelCase__      			=						getattr(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)
																							lowerCAmelCase__      			=						doctest.DocTestSuite(SCREAMING_SNAKE_CASE_	)
																							lowerCAmelCase__      			=						unittest.TextTestRunner().run(SCREAMING_SNAKE_CASE_	)
																							self.assertIs(len(result.failures	) ,							0	)
																			except AttributeError:
																							logger.info(f'{module_identifier} is not a module.'	)
															else:
																			lowerCAmelCase__      			=						doctest.testfile(str('''..''' / directory / file	) ,							optionflags=doctest.ELLIPSIS	)
																			self.assertIs(result.failed ,							0	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						'''modeling'''
											lowerCAmelCase__      			=						[
											    '''modeling_ctrl.py''',
											    '''modeling_tf_ctrl.py''',
											]
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							identifier=SCREAMING_SNAKE_CASE_ ,							ignore_files=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						'''tokenization'''
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							identifier=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						'''configuration'''
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							identifier=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						Path('''src/transformers'''	)
											lowerCAmelCase__      			=						['''configuration''', '''modeling''', '''tokenization''']
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							n_identifier=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						Path('''docs/source'''	)
											lowerCAmelCase__      			=						['''favicon.ico''']
											self.analyze_directory(SCREAMING_SNAKE_CASE_ ,							ignore_files=SCREAMING_SNAKE_CASE_ ,							only_modules=SCREAMING_SNAKE_CASE_	)





