



'''simple docstring'''

import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
			from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor

class 							a__:






			def __init__(     self					,   _UpperCAmelCase					,   _UpperCAmelCase=13					,   _UpperCAmelCase=32					,   _UpperCAmelCase=2					,   _UpperCAmelCase=3					,   _UpperCAmelCase=16					,   _UpperCAmelCase=[1, 2, 1]					,   _UpperCAmelCase=[2, 2, 4]					,   _UpperCAmelCase=2					,   _UpperCAmelCase=2.0					,   _UpperCAmelCase=True					,   _UpperCAmelCase=0.0					,   _UpperCAmelCase=0.0					,   _UpperCAmelCase=0.1					,   _UpperCAmelCase="gelu"					,   _UpperCAmelCase=False					,   _UpperCAmelCase=True					,   _UpperCAmelCase=0.02					,   _UpperCAmelCase=1E-5					,   _UpperCAmelCase=True					,   _UpperCAmelCase=None					,   _UpperCAmelCase=True					,   _UpperCAmelCase=10					,   _UpperCAmelCase=8					,   )							->							List[Any]:
					snake_case__	     =parent
					snake_case__	     =batch_size
					snake_case__	     =image_size
					snake_case__	     =patch_size
					snake_case__	     =num_channels
					snake_case__	     =embed_dim
					snake_case__	     =depths
					snake_case__	     =num_heads
					snake_case__	     =window_size
					snake_case__	     =mlp_ratio
					snake_case__	     =qkv_bias
					snake_case__	     =hidden_dropout_prob
					snake_case__	     =attention_probs_dropout_prob
					snake_case__	     =drop_path_rate
					snake_case__	     =hidden_act
					snake_case__	     =use_absolute_embeddings
					snake_case__	     =patch_norm
					snake_case__	     =layer_norm_eps
					snake_case__	     =initializer_range
					snake_case__	     =is_training
					snake_case__	     =scope
					snake_case__	     =use_labels
					snake_case__	     =type_sequence_label_size
					snake_case__	     =encoder_stride






			def 						_lowercase  (     self						)							->							str:
					snake_case__	     =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

					snake_case__	     =self.get_config()

					return config, pixel_values, labels






			def 						_lowercase  (     self						)							->							List[Any]:
					return SwinvaConfig(
					    image_size=self.image_size					,   patch_size=self.patch_size					,   num_channels=self.num_channels					,   embed_dim=self.embed_dim					,   depths=self.depths					,   num_heads=self.num_heads					,   window_size=self.window_size					,   mlp_ratio=self.mlp_ratio					,   qkv_bias=self.qkv_bias					,   hidden_dropout_prob=self.hidden_dropout_prob					,   attention_probs_dropout_prob=self.attention_probs_dropout_prob					,   drop_path_rate=self.drop_path_rate					,   hidden_act=self.hidden_act					,   use_absolute_embeddings=self.use_absolute_embeddings					,   path_norm=self.patch_norm					,   layer_norm_eps=self.layer_norm_eps					,   initializer_range=self.initializer_range					,   encoder_stride=self.encoder_stride					,   )






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							List[Any]:
					snake_case__	     =SwinvaModel(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase						)

					snake_case__	     =((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
					snake_case__	     =int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

					self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, expected_seq_len, expected_dim)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							List[Any]:
					snake_case__	     =SwinvaForMaskedImageModeling(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase						)
					self.parent.assertEqual(
					    result.logits.shape					,   (self.batch_size, self.num_channels, self.image_size, self.image_size)						)

					# test greyscale images
					snake_case__	     =1
					snake_case__	     =SwinvaForMaskedImageModeling(_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()

					snake_case__	     =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
					snake_case__	     =model(_UpperCAmelCase						)
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, 1, self.image_size, self.image_size)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Union[str, Any]:
					snake_case__	     =self.type_sequence_label_size
					snake_case__	     =SwinvaForImageClassification(_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   labels=_UpperCAmelCase						)
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.type_sequence_label_size)						)






			def 						_lowercase  (     self						)							->							Optional[int]:
					snake_case__	     =self.prepare_config_and_inputs()
					snake_case__     ,	snake_case__     ,	snake_case__	     =config_and_inputs
					snake_case__	     ={'pixel_values': pixel_values}
					return config, inputs_dict





@require_torch
class 							a__( snake_case__   ,      snake_case__   ,      unittest.TestCase     ):
			a_	: Dict									=      (
			    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
			)
			a_	: str									=      (
			    {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
			    if is_torch_available()
			    else {}
			)

			a_	: int									=      False
			a_	: Any									=      False
			a_	: Optional[Any]									=      False
			a_	: List[Any]									=      False






			def 						_lowercase  (     self						)							->							List[str]:
					snake_case__	     =SwinvaModelTester(self						)
					snake_case__	     =ConfigTester(self					,   config_class=_UpperCAmelCase					,   embed_dim=37						)






			def 						_lowercase  (     self						)							->							Any:
					self.config_tester.create_and_test_config_to_json_string()
					self.config_tester.create_and_test_config_to_json_file()
					self.config_tester.create_and_test_config_from_and_save_pretrained()
					self.config_tester.create_and_test_config_with_num_labels()
					self.config_tester.check_config_can_be_init_without_params()
					self.config_tester.check_config_arguments_init()






			def 						_lowercase  (     self						)							->							Tuple:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*_UpperCAmelCase						)






			@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'						)
			def 						_lowercase  (     self						)							->							List[str]:
					pass






			@unittest.skip(reason='Swinv2 does not use inputs_embeds'						)
			def 						_lowercase  (     self						)							->							Optional[Any]:
					pass






			def 						_lowercase  (     self						)							->							str:
					snake_case__     ,	snake_case__	     =self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
							snake_case__	     =model_class(_UpperCAmelCase						)
							self.assertIsInstance(model.get_input_embeddings()					,   (nn.Module)						)
							snake_case__	     =model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(_UpperCAmelCase					,   nn.Linear						)						)






			def 						_lowercase  (     self						)							->							List[str]:
					snake_case__     ,	snake_case__	     =self.model_tester.prepare_config_and_inputs_for_common()

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

							snake_case__	     =['pixel_values']
							self.assertListEqual(arg_names[:1]					,   _UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							List[Any]:
					snake_case__     ,	snake_case__	     =self.model_tester.prepare_config_and_inputs_for_common()
					snake_case__	     =True

					for model_class in self.all_model_classes:
							snake_case__	     =True
							snake_case__	     =False
							snake_case__	     =True
							snake_case__	     =model_class(_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							with torch.no_grad():
									snake_case__	     =model(**self._prepare_for_class(_UpperCAmelCase					,   _UpperCAmelCase						)						)
							snake_case__	     =outputs.attentions
							snake_case__	     =len(self.model_tester.depths						)
							self.assertEqual(len(_UpperCAmelCase						)					,   _UpperCAmelCase						)

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							snake_case__	     =True
							snake_case__	     =config.window_size**2
							snake_case__	     =model_class(_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							with torch.no_grad():
									snake_case__	     =model(**self._prepare_for_class(_UpperCAmelCase					,   _UpperCAmelCase						)						)
							snake_case__	     =outputs.attentions
							self.assertEqual(len(_UpperCAmelCase						)					,   _UpperCAmelCase						)

							self.assertListEqual(
							    list(attentions[0].shape[-3:]						)					,   [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,   )
							snake_case__	     =len(_UpperCAmelCase						)

							# Check attention is always last and order is fine
							snake_case__	     =True
							snake_case__	     =True
							snake_case__	     =model_class(_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							with torch.no_grad():
									snake_case__	     =model(**self._prepare_for_class(_UpperCAmelCase					,   _UpperCAmelCase						)						)

							if hasattr(self.model_tester					,   'num_hidden_states_types'						):
									snake_case__	     =self.model_tester.num_hidden_states_types
							else:
									# also another +1 for reshaped_hidden_states
									snake_case__	     =2
							self.assertEqual(out_len + added_hidden_states					,   len(_UpperCAmelCase						)						)

							snake_case__	     =outputs.attentions

							self.assertEqual(len(_UpperCAmelCase						)					,   _UpperCAmelCase						)

							self.assertListEqual(
							    list(self_attentions[0].shape[-3:]						)					,   [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,   )






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							List[Any]:
					snake_case__	     =model_class(_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()

					with torch.no_grad():
							snake_case__	     =model(**self._prepare_for_class(_UpperCAmelCase					,   _UpperCAmelCase						)						)

					snake_case__	     =outputs.hidden_states

					snake_case__	     =getattr(
					    self.model_tester					,   'expected_num_hidden_layers'					,   len(self.model_tester.depths						) + 1						)
					self.assertEqual(len(_UpperCAmelCase						)					,   _UpperCAmelCase						)

					# Swinv2 has a different seq_length
					snake_case__	     =(
					    config.patch_size
					    if isinstance(config.patch_size					,   collections.abc.Iterable						)
					    else (config.patch_size, config.patch_size)
					)

					snake_case__	     =(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

					self.assertListEqual(
					    list(hidden_states[0].shape[-2:]						)					,   [num_patches, self.model_tester.embed_dim]					,   )

					snake_case__	     =outputs.reshaped_hidden_states
					self.assertEqual(len(_UpperCAmelCase						)					,   _UpperCAmelCase						)

					snake_case__     ,	snake_case__     ,	snake_case__     ,	snake_case__	     =reshaped_hidden_states[0].shape
					snake_case__	     =(
					    reshaped_hidden_states[0].view(_UpperCAmelCase					,   _UpperCAmelCase					,   height * width						).permute(0					,   2					,   1						)
					)
					self.assertListEqual(
					    list(reshaped_hidden_states.shape[-2:]						)					,   [num_patches, self.model_tester.embed_dim]					,   )






			def 						_lowercase  (     self						)							->							List[str]:
					snake_case__     ,	snake_case__	     =self.model_tester.prepare_config_and_inputs_for_common()

					snake_case__	     =(
					    self.model_tester.image_size
					    if isinstance(self.model_tester.image_size					,   collections.abc.Iterable						)
					    else (self.model_tester.image_size, self.model_tester.image_size)
					)

					for model_class in self.all_model_classes:
							snake_case__	     =True
							self.check_hidden_states_output(_UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)

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

							self.check_hidden_states_output(_UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							str:
					snake_case__     ,	snake_case__	     =self.model_tester.prepare_config_and_inputs_for_common()
					snake_case__	     =3

					snake_case__	     =(
					    self.model_tester.image_size
					    if isinstance(self.model_tester.image_size					,   collections.abc.Iterable						)
					    else (self.model_tester.image_size, self.model_tester.image_size)
					)
					snake_case__	     =(
					    config.patch_size
					    if isinstance(config.patch_size					,   collections.abc.Iterable						)
					    else (config.patch_size, config.patch_size)
					)

					snake_case__	     =image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
					snake_case__	     =image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

					for model_class in self.all_model_classes:
							snake_case__	     =True
							self.check_hidden_states_output(_UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   (padded_height, padded_width)						)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							snake_case__	     =True
							self.check_hidden_states_output(_UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   (padded_height, padded_width)						)






			def 						_lowercase  (     self						)							->							Optional[int]:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Any:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase						)






			@slow
			def 						_lowercase  (     self						)							->							Dict:
					for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							snake_case__	     =SwinvaModel.from_pretrained(_UpperCAmelCase						)
							self.assertIsNotNone(_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							List[str]:
					snake_case__     ,	snake_case__	     =self.model_tester.prepare_config_and_inputs_for_common()

					snake_case__	     =_config_zero_init(_UpperCAmelCase						)
					for model_class in self.all_model_classes:
							snake_case__	     =model_class(config=_UpperCAmelCase						)
							for name, param in model.named_parameters():
									if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
											self.assertIn(
											    ((param.data.mean() * 1E9).round() / 1E9).item()					,   [0.0, 1.0]					,   msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""					,   )





@require_vision
@require_torch
class 							a__( unittest.TestCase     ):






			@cached_property
			def 						_lowercase  (     self						)							->							List[Any]:
					return (
					    AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'						)
					    if is_vision_available()
					    else None
					)






			@slow
			def 						_lowercase  (     self						)							->							List[Any]:
					snake_case__	     =SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'						).to(
					    _UpperCAmelCase						)
					snake_case__	     =self.default_image_processor

					snake_case__	     =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
					snake_case__	     =image_processor(images=_UpperCAmelCase					,   return_tensors='pt'						).to(_UpperCAmelCase						)

					# forward pass
					with torch.no_grad():
							snake_case__	     =model(**_UpperCAmelCase						)

					# verify the logits
					snake_case__	     =torch.Size((1, 1000)						)
					self.assertEqual(outputs.logits.shape					,   _UpperCAmelCase						)
					snake_case__	     =torch.tensor([-0.3_947, -0.4_306, 0.0_026]						).to(_UpperCAmelCase						)
					self.assertTrue(torch.allclose(outputs.logits[0, :3]					,   _UpperCAmelCase					,   atol=1E-4						)						)









'''simple docstring'''

import collections
import os
import re
from pathlib import Path


SCREAMING_SNAKE_CASE__     :						List[Any]	=  '''src/transformers'''


# Matches is_xxx_available()
SCREAMING_SNAKE_CASE__     :						List[str]	=  re.compile(r'''is\_([a-z_]*)_available()''')
# Catches a one-line _import_struct = {xxx}
SCREAMING_SNAKE_CASE__     :						Optional[Any]	=  re.compile(r'''^_import_structure\s+=\s+\{([^\}]+)\}''')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
SCREAMING_SNAKE_CASE__     :						List[str]	=  re.compile(r'''\s+"\S*":\s+\[([^\]]*)\]''')
# Catches a line if not is_foo_available
SCREAMING_SNAKE_CASE__     :						List[str]	=  re.compile(r'''^\s*if\s+not\s+is\_[a-z_]*\_available\(\)''')
# Catches a line _import_struct["bla"].append("foo")
SCREAMING_SNAKE_CASE__     :						Union[str, Any]	=  re.compile(r'''^\s*_import_structure\["\S*"\]\.append\("(\S*)"\)''')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
SCREAMING_SNAKE_CASE__     :						Tuple	=  re.compile(r'''^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]''')
# Catches a line with an object between quotes and a comma:     "MyModel",
SCREAMING_SNAKE_CASE__     :						Any	=  re.compile(r'''^\s+"([^"]+)",''')
# Catches a line with objects between brackets only:    ["foo", "bar"],
SCREAMING_SNAKE_CASE__     :						List[Any]	=  re.compile(r'''^\s+\[([^\]]+)\]''')
# Catches a line with from foo import bar, bla, boo
SCREAMING_SNAKE_CASE__     :						Optional[int]	=  re.compile(r'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
# Catches a line with try:
SCREAMING_SNAKE_CASE__     :						str	=  re.compile(r'''^\s*try:''')
# Catches a line with else:
SCREAMING_SNAKE_CASE__     :						Any	=  re.compile(r'''^\s*else:''')






def 				a  (     UpperCamelCase_    :    Dict			)       ->	List[str]:
		if _re_test_backend.search(UpperCamelCase_			) is None:
				return None
		snake_case__	     =[b[0] for b in _re_backend.findall(UpperCamelCase_			)]
		backends.sort()
		return "_and_".join(UpperCamelCase_			)






def 				a  (     UpperCamelCase_    :    List[Any]			)       ->	Tuple:
		with open(UpperCamelCase_      ,					'r'      ,					encoding='utf-8'      ,					newline='\n'			) as f:
				snake_case__	     =f.readlines()

		snake_case__	     =0
		while line_index < len(UpperCamelCase_			) and not lines[line_index].startswith('_import_structure = {'			):
				line_index += 1

		# If this is a traditional init, just return.
		if line_index >= len(UpperCamelCase_			):
				return None

		# First grab the objects without a specific backend in _import_structure
		snake_case__	     =[]
		while not lines[line_index].startswith('if TYPE_CHECKING'			) and find_backend(lines[line_index]			) is None:
				snake_case__	     =lines[line_index]
				# If we have everything on a single line, let's deal with it.
				if _re_one_line_import_struct.search(UpperCamelCase_			):
						snake_case__	     =_re_one_line_import_struct.search(UpperCamelCase_			).groups()[0]
						snake_case__	     =re.findall(r'\[([^\]]+)\]'      ,					UpperCamelCase_			)
						for imp in imports:
								objects.extend([obj[1:-1] for obj in imp.split(', '			)]			)
						line_index += 1
						continue
				snake_case__	     =_re_import_struct_key_value.search(UpperCamelCase_			)
				if single_line_import_search is not None:
						snake_case__	     =[obj[1:-1] for obj in single_line_import_search.groups()[0].split(', '			) if len(UpperCamelCase_			) > 0]
						objects.extend(UpperCamelCase_			)
				elif line.startswith(' ' * 8 + '"'			):
						objects.append(line[9:-3]			)
				line_index += 1

		snake_case__	     ={'none': objects}
		# Let's continue with backend-specific objects in _import_structure
		while not lines[line_index].startswith('if TYPE_CHECKING'			):
				# If the line is an if not is_backend_available, we grab all objects associated.
				snake_case__	     =find_backend(lines[line_index]			)
				# Check if the backend declaration is inside a try block:
				if _re_try.search(lines[line_index - 1]			) is None:
						snake_case__	     =None

				if backend is not None:
						line_index += 1

						# Scroll until we hit the else block of try-except-else
						while _re_else.search(lines[line_index]			) is None:
								line_index += 1

						line_index += 1

						snake_case__	     =[]
						# Until we unindent, add backend objects to the list
						while len(lines[line_index]			) <= 1 or lines[line_index].startswith(' ' * 4			):
								snake_case__	     =lines[line_index]
								if _re_import_struct_add_one.search(UpperCamelCase_			) is not None:
										objects.append(_re_import_struct_add_one.search(UpperCamelCase_			).groups()[0]			)
								elif _re_import_struct_add_many.search(UpperCamelCase_			) is not None:
										snake_case__	     =_re_import_struct_add_many.search(UpperCamelCase_			).groups()[0].split(', '			)
										snake_case__	     =[obj[1:-1] for obj in imports if len(UpperCamelCase_			) > 0]
										objects.extend(UpperCamelCase_			)
								elif _re_between_brackets.search(UpperCamelCase_			) is not None:
										snake_case__	     =_re_between_brackets.search(UpperCamelCase_			).groups()[0].split(', '			)
										snake_case__	     =[obj[1:-1] for obj in imports if len(UpperCamelCase_			) > 0]
										objects.extend(UpperCamelCase_			)
								elif _re_quote_object.search(UpperCamelCase_			) is not None:
										objects.append(_re_quote_object.search(UpperCamelCase_			).groups()[0]			)
								elif line.startswith(' ' * 8 + '"'			):
										objects.append(line[9:-3]			)
								elif line.startswith(' ' * 12 + '"'			):
										objects.append(line[13:-3]			)
								line_index += 1

						snake_case__	     =objects
				else:
						line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
		snake_case__	     =[]
		while (
		    line_index < len(UpperCamelCase_			)
		    and find_backend(lines[line_index]			) is None
		    and not lines[line_index].startswith('else'			)
		):
				snake_case__	     =lines[line_index]
				snake_case__	     =_re_import.search(UpperCamelCase_			)
				if single_line_import_search is not None:
						objects.extend(single_line_import_search.groups()[0].split(', '			)			)
				elif line.startswith(' ' * 8			):
						objects.append(line[8:-2]			)
				line_index += 1

		snake_case__	     ={'none': objects}
		# Let's continue with backend-specific objects
		while line_index < len(UpperCamelCase_			):
				# If the line is an if is_backend_available, we grab all objects associated.
				snake_case__	     =find_backend(lines[line_index]			)
				# Check if the backend declaration is inside a try block:
				if _re_try.search(lines[line_index - 1]			) is None:
						snake_case__	     =None

				if backend is not None:
						line_index += 1

						# Scroll until we hit the else block of try-except-else
						while _re_else.search(lines[line_index]			) is None:
								line_index += 1

						line_index += 1

						snake_case__	     =[]
						# Until we unindent, add backend objects to the list
						while len(lines[line_index]			) <= 1 or lines[line_index].startswith(' ' * 8			):
								snake_case__	     =lines[line_index]
								snake_case__	     =_re_import.search(UpperCamelCase_			)
								if single_line_import_search is not None:
										objects.extend(single_line_import_search.groups()[0].split(', '			)			)
								elif line.startswith(' ' * 12			):
										objects.append(line[12:-2]			)
								line_index += 1

						snake_case__	     =objects
				else:
						line_index += 1

		return import_dict_objects, type_hint_objects






def 				a  (     UpperCamelCase_    :    int      ,					UpperCamelCase_    :    List[Any]			)       ->	Union[str, Any]:

		def find_duplicates(UpperCamelCase_    :    Tuple			):
				return [k for k, v in collections.Counter(UpperCamelCase_			).items() if v > 1]

		if list(import_dict_objects.keys()			) != list(type_hint_objects.keys()			):
				return ["Both sides of the init do not have the same backends!"]

		snake_case__	     =[]
		for key in import_dict_objects.keys():
				snake_case__	     =find_duplicates(import_dict_objects[key]			)
				if duplicate_imports:
						errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""			)
				snake_case__	     =find_duplicates(type_hint_objects[key]			)
				if duplicate_type_hints:
						errors.append(f"""Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}"""			)

				if sorted(set(import_dict_objects[key]			)			) != sorted(set(type_hint_objects[key]			)			):
						snake_case__	     ='base imports' if key == 'none' else f"""{key} backend"""
						errors.append(f"""Differences for {name}:"""			)
						for a in type_hint_objects[key]:
								if a not in import_dict_objects[key]:
										errors.append(f"""  {a} in TYPE_HINT but not in _import_structure."""			)
						for a in import_dict_objects[key]:
								if a not in type_hint_objects[key]:
										errors.append(f"""  {a} in _import_structure but not in TYPE_HINT."""			)
		return errors






def 				a  (     )       ->	Optional[Any]:
		snake_case__	     =[]
		for root, _, files in os.walk(UpperCamelCase_			):
				if "__init__.py" in files:
						snake_case__	     =os.path.join(UpperCamelCase_      ,					'__init__.py'			)
						snake_case__	     =parse_init(UpperCamelCase_			)
						if objects is not None:
								snake_case__	     =analyze_results(*UpperCamelCase_			)
								if len(UpperCamelCase_			) > 0:
										snake_case__	     =f"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
										failures.append('\n'.join(UpperCamelCase_			)			)
		if len(UpperCamelCase_			) > 0:
				raise ValueError('\n\n'.join(UpperCamelCase_			)			)






def 				a  (     )       ->	Dict:
		snake_case__	     =[]
		for path, directories, files in os.walk(UpperCamelCase_			):
				for folder in directories:
						# Ignore private modules
						if folder.startswith('_'			):
								directories.remove(UpperCamelCase_			)
								continue
						# Ignore leftovers from branches (empty folders apart from pycache)
						if len(list((Path(UpperCamelCase_			) / folder).glob('*.py'			)			)			) == 0:
								continue
						snake_case__	     =str((Path(UpperCamelCase_			) / folder).relative_to(UpperCamelCase_			)			)
						snake_case__	     =short_path.replace(os.path.sep      ,					'.'			)
						submodules.append(UpperCamelCase_			)
				for fname in files:
						if fname == "__init__.py":
								continue
						snake_case__	     =str((Path(UpperCamelCase_			) / fname).relative_to(UpperCamelCase_			)			)
						snake_case__	     =short_path.replace('.py'      ,					''			).replace(os.path.sep      ,					'.'			)
						if len(submodule.split('.'			)			) == 1:
								submodules.append(UpperCamelCase_			)
		return submodules


SCREAMING_SNAKE_CASE__     :						Union[str, Any]	=  [
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
    '''models.esm.openfold_utils''',
]






def 				a  (     )       ->	Union[str, Any]:
		# This is to make sure the transformers module imported is the one in the repo.
		from transformers.utils import direct_transformers_import

		snake_case__	     =direct_transformers_import(UpperCamelCase_			)

		snake_case__	     =set(transformers._import_structure.keys()			)
		# This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
		# some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
		# (potentiall re-) add them.
		with open(os.path.join(UpperCamelCase_      ,					'__init__.py'			)      ,					'r'			) as f:
				snake_case__	     =f.read()
		import_structure_keys.update(set(re.findall(r'import_structure\[\"([^\"]*)\"\]'      ,					UpperCamelCase_			)			)			)

		snake_case__	     =[
		    module
		    for module in get_transformers_submodules()
		    if module not in IGNORE_SUBMODULES and module not in import_structure_keys
		]

		if len(UpperCamelCase_			) > 0:
				snake_case__	     ='\n'.join(f"""- {module}""" for module in module_not_registered			)
				raise ValueError(
				    'The following submodules are not properly registed in the main init of Transformers:\n'
				    f"""{list_of_modules}\n"""
				    'Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.'			)


if __name__ == "__main__":
			check_all_inits()
			check_submodules()




