






import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
   from transformers import (
       FlaxBertModel,
       FlaxCLIPVisionModel,
       FlaxVisionTextDualEncoderModel,
       FlaxViTModel,
       VisionTextDualEncoderConfig,
       VisionTextDualEncoderProcessor,
   )
   from transformers.modeling_flax_pytorch_utils import (
       convert_pytorch_state_dict_to_flax,
       load_flax_weights_in_pytorch_model,
   )


if is_torch_available():
   import torch

   from transformers import VisionTextDualEncoderModel

if is_vision_available():
   from PIL import Image

def     snake_case   (UpperCAmelCase__    )			->							int:
  if isinstance(UpperCAmelCase__      ,       collections.abc.Iterable    ):
    return x
  return (x, x)




@require_flax
class 							_lowerCAmelCase:





       """simple docstring"""







       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         pass





       def      _a       (   self				):
         pass





       def      _a       (   self				):
         pass





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         UpperCamelCase_:   str        =							np.abs((a - b)				).max()
         self.assertLessEqual(_lowerCamelCase    ,     _lowerCamelCase    ,     f'''Difference between torch and flax is {diff} (>= {tol}).'''				)





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase=None    ,     **_lowerCamelCase				):
         UpperCamelCase_:   str        =							VisionTextDualEncoderConfig.from_vision_text_configs(_lowerCamelCase    ,     _lowerCamelCase				)

         UpperCamelCase_:   Any        =							FlaxVisionTextDualEncoderModel(_lowerCamelCase				)

         UpperCamelCase_:   Optional[int]        =							model(input_ids=_lowerCamelCase    ,     pixel_values=_lowerCamelCase    ,     attention_mask=_lowerCamelCase				)

         self.assertEqual(output['text_embeds'].shape    ,     (input_ids.shape[0], config.projection_dim)				)
         self.assertEqual(output['image_embeds'].shape    ,     (pixel_values.shape[0], config.projection_dim)				)





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase=None    ,     **_lowerCamelCase				):
         UpperCamelCase_ ,UpperCamelCase_:   Optional[Any]        =							self.get_vision_text_model(_lowerCamelCase    ,     _lowerCamelCase				)
         UpperCamelCase_:   List[str]        =							{'vision_model': vision_model, 'text_model': text_model}
         UpperCamelCase_:   List[Any]        =							FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**_lowerCamelCase				)

         UpperCamelCase_:   Union[str, Any]        =							model(input_ids=_lowerCamelCase    ,     pixel_values=_lowerCamelCase    ,     attention_mask=_lowerCamelCase				)

         self.assertEqual(output['text_embeds'].shape    ,     (input_ids.shape[0], model.config.projection_dim)				)
         self.assertEqual(output['image_embeds'].shape    ,     (pixel_values.shape[0], model.config.projection_dim)				)





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase=None    ,     **_lowerCamelCase				):
         UpperCamelCase_ ,UpperCamelCase_:   Optional[Any]        =							self.get_vision_text_model(_lowerCamelCase    ,     _lowerCamelCase				)
         UpperCamelCase_:   Optional[int]        =							{'vision_model': vision_model, 'text_model': text_model}
         UpperCamelCase_:   Any        =							FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**_lowerCamelCase				)

         UpperCamelCase_:   Optional[Any]        =							model(input_ids=_lowerCamelCase    ,     pixel_values=_lowerCamelCase    ,     attention_mask=_lowerCamelCase				)
         UpperCamelCase_:   Any        =							output[0]

         with tempfile.TemporaryDirectory() as tmpdirname:
           model.save_pretrained(_lowerCamelCase				)
           UpperCamelCase_:   Union[str, Any]        =							FlaxVisionTextDualEncoderModel.from_pretrained(_lowerCamelCase				)

           UpperCamelCase_:   Any        =							model(input_ids=_lowerCamelCase    ,     pixel_values=_lowerCamelCase    ,     attention_mask=_lowerCamelCase				)
           UpperCamelCase_:   int        =							after_output[0]
           UpperCamelCase_:   Dict        =							np.amax(np.abs(out_a - out_a				)				)
           self.assertLessEqual(_lowerCamelCase    ,     1e-3				)





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase=None    ,     **_lowerCamelCase				):
         UpperCamelCase_ ,UpperCamelCase_:   Optional[Any]        =							self.get_vision_text_model(_lowerCamelCase    ,     _lowerCamelCase				)
         UpperCamelCase_:   List[Any]        =							{'vision_model': vision_model, 'text_model': text_model}
         UpperCamelCase_:   Optional[int]        =							FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**_lowerCamelCase				)

         UpperCamelCase_:   List[str]        =							model(
             input_ids=_lowerCamelCase    ,     pixel_values=_lowerCamelCase    ,     attention_mask=_lowerCamelCase    ,     output_attentions=_lowerCamelCase				)

         UpperCamelCase_:   List[str]        =							output.vision_model_output.attentions
         self.assertEqual(len(_lowerCamelCase				)    ,     vision_config.num_hidden_layers				)

         # in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
         UpperCamelCase_:   Any        =							to_atuple(vision_model.config.image_size				)
         UpperCamelCase_:   Union[str, Any]        =							to_atuple(vision_model.config.patch_size				)
         UpperCamelCase_:   int        =							(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
         UpperCamelCase_:   Optional[int]        =							num_patches + 1
         self.assertEqual(vision_attentions[0].shape[-3:]    ,     (vision_config.num_attention_heads, seq_len, seq_len)				)

         UpperCamelCase_:   str        =							output.text_model_output.attentions
         self.assertEqual(len(_lowerCamelCase				)    ,     text_config.num_hidden_layers				)

         self.assertEqual(
             text_attentions[0].shape[-3:]    ,     (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])    ,     )





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         pt_model.to(_lowerCamelCase				)
         pt_model.eval()

         # prepare inputs
         UpperCamelCase_:   Optional[Any]        =							inputs_dict
         UpperCamelCase_:   Optional[int]        =							{k: torch.tensor(v.tolist()				) for k, v in flax_inputs.items()}

         with torch.no_grad():
           UpperCamelCase_:   Union[str, Any]        =							pt_model(**_lowerCamelCase				).to_tuple()

         UpperCamelCase_:   List[Any]        =							fx_model(**_lowerCamelCase				).to_tuple()
         self.assertEqual(len(_lowerCamelCase				)    ,     len(_lowerCamelCase				)    ,     'Output lengths differ between Flax and PyTorch'				)
         for fx_output, pt_output in zip(fx_outputs[:4]    ,     pt_outputs[:4]				):
           self.assert_almost_equals(_lowerCamelCase    ,     pt_output.numpy()    ,     4e-2				)

         # PT -> Flax
         with tempfile.TemporaryDirectory() as tmpdirname:
           pt_model.save_pretrained(_lowerCamelCase				)
           UpperCamelCase_:   int        =							FlaxVisionTextDualEncoderModel.from_pretrained(_lowerCamelCase    ,     from_pt=_lowerCamelCase				)

         UpperCamelCase_:   List[Any]        =							fx_model_loaded(**_lowerCamelCase				).to_tuple()
         self.assertEqual(len(_lowerCamelCase				)    ,     len(_lowerCamelCase				)    ,     'Output lengths differ between Flax and PyTorch'				)
         for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4]    ,     pt_outputs[:4]				):
           self.assert_almost_equals(_lowerCamelCase    ,     pt_output.numpy()    ,     4e-2				)

         # Flax -> PT
         with tempfile.TemporaryDirectory() as tmpdirname:
           fx_model.save_pretrained(_lowerCamelCase				)
           UpperCamelCase_:   Any        =							VisionTextDualEncoderModel.from_pretrained(_lowerCamelCase    ,     from_flax=_lowerCamelCase				)

         pt_model_loaded.to(_lowerCamelCase				)
         pt_model_loaded.eval()

         with torch.no_grad():
           UpperCamelCase_:   int        =							pt_model_loaded(**_lowerCamelCase				).to_tuple()

         self.assertEqual(len(_lowerCamelCase				)    ,     len(_lowerCamelCase				)    ,     'Output lengths differ between Flax and PyTorch'				)
         for fx_output, pt_output_loaded in zip(fx_outputs[:4]    ,     pt_outputs_loaded[:4]				):
           self.assert_almost_equals(_lowerCamelCase    ,     pt_output_loaded.numpy()    ,     4e-2				)





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         UpperCamelCase_:   Optional[int]        =							VisionTextDualEncoderConfig.from_vision_text_configs(_lowerCamelCase    ,     _lowerCamelCase				)

         UpperCamelCase_:   int        =							VisionTextDualEncoderModel(_lowerCamelCase				)
         UpperCamelCase_:   str        =							FlaxVisionTextDualEncoderModel(_lowerCamelCase				)

         UpperCamelCase_:   List[Any]        =							convert_pytorch_state_dict_to_flax(pt_model.state_dict()    ,     _lowerCamelCase				)
         UpperCamelCase_:   List[str]        =							fx_state

         self.check_pt_flax_equivalence(_lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				)





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         UpperCamelCase_:   str        =							VisionTextDualEncoderConfig.from_vision_text_configs(_lowerCamelCase    ,     _lowerCamelCase				)

         UpperCamelCase_:   Tuple        =							VisionTextDualEncoderModel(_lowerCamelCase				)
         UpperCamelCase_:   str        =							FlaxVisionTextDualEncoderModel(_lowerCamelCase				)

         UpperCamelCase_:   List[Any]        =							load_flax_weights_in_pytorch_model(_lowerCamelCase    ,     fx_model.params				)

         self.check_pt_flax_equivalence(_lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				)





       def      _a       (   self				):
         UpperCamelCase_:   str        =							self.prepare_config_and_inputs()
         self.check_model_from_pretrained_configs(**_lowerCamelCase				)





       def      _a       (   self				):
         UpperCamelCase_:   int        =							self.prepare_config_and_inputs()
         self.check_vision_text_dual_encoder_from_pretrained(**_lowerCamelCase				)





       def      _a       (   self				):
         UpperCamelCase_:   Optional[Any]        =							self.prepare_config_and_inputs()
         self.check_save_load(**_lowerCamelCase				)





       def      _a       (   self				):
         UpperCamelCase_:   int        =							self.prepare_config_and_inputs()
         self.check_vision_text_output_attention(**_lowerCamelCase				)





       @is_pt_flax_cross_test
       def      _a       (   self				):
         UpperCamelCase_:   Dict        =							self.prepare_config_and_inputs()
         UpperCamelCase_:   str        =							config_inputs_dict.pop('vision_config'				)
         UpperCamelCase_:   Dict        =							config_inputs_dict.pop('text_config'				)

         UpperCamelCase_:   int        =							config_inputs_dict

         self.check_equivalence_pt_to_flax(_lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				)
         self.check_equivalence_flax_to_pt(_lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase				)





       @slow
       def      _a       (   self				):
         UpperCamelCase_ ,UpperCamelCase_:   int        =							self.get_pretrained_model_and_inputs()

         UpperCamelCase_:   Optional[Any]        =							model_a(**_lowerCamelCase				)
         UpperCamelCase_:   Any        =							outputs[0]

         with tempfile.TemporaryDirectory() as tmp_dirname:
           model_a.save_pretrained(_lowerCamelCase				)
           UpperCamelCase_:   str        =							FlaxVisionTextDualEncoderModel.from_pretrained(_lowerCamelCase				)

           UpperCamelCase_:   str        =							model_a(**_lowerCamelCase				)
           UpperCamelCase_:   str        =							after_outputs[0]
           UpperCamelCase_:   Optional[Any]        =							np.amax(np.abs(out_a - out_a				)				)
           self.assertLessEqual(_lowerCamelCase    ,     1e-5				)







@require_flax
class 							_lowerCAmelCase(			UpperCAmelCase_				,      unittest.TestCase   ):





       """simple docstring"""







       def      _a       (   self				):
         UpperCamelCase_:   Optional[int]        =							FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
             'hf-internal-testing/tiny-random-vit'    ,     'hf-internal-testing/tiny-bert'    ,     vision_from_pt=_lowerCamelCase    ,     text_from_pt=_lowerCamelCase    ,     )
         UpperCamelCase_:   List[Any]        =							1_3
         UpperCamelCase_:   Tuple        =							floats_tensor(
             [
                 batch_size,
                 model.config.vision_config.num_channels,
                 model.config.vision_config.image_size,
                 model.config.vision_config.image_size,
             ]				)
         UpperCamelCase_:   Union[str, Any]        =							ids_tensor([batch_size, 4]    ,     model.config.text_config.vocab_size				)
         UpperCamelCase_:   str        =							random_attention_mask([batch_size, 4]				)
         UpperCamelCase_:   Optional[int]        =							{'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

         return model, inputs





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         UpperCamelCase_:   Any        =							FlaxViTModel(_lowerCamelCase				)
         UpperCamelCase_:   Dict        =							FlaxBertModel(_lowerCamelCase				)
         return vision_model, text_model





       def      _a       (   self				):
         UpperCamelCase_:   Union[str, Any]        =							FlaxViTModelTester(self				)
         UpperCamelCase_:   Dict        =							FlaxBertModelTester(self				)
         UpperCamelCase_:   Tuple        =							vit_model_tester.prepare_config_and_inputs()
         UpperCamelCase_:   Optional[int]        =							bert_model_tester.prepare_config_and_inputs()

         UpperCamelCase_ ,UpperCamelCase_:   Tuple        =							vision_config_and_inputs

         UpperCamelCase_ ,UpperCamelCase_ ,UpperCamelCase_ ,UpperCamelCase_:   Optional[int]        =							text_config_and_inputs

         # make sure that cross attention layers are added
         return {
             "text_config": text_config,
             "vision_config": vision_config,
             "pixel_values": pixel_values,
             "attention_mask": attention_mask,
             "input_ids": input_ids,
             "token_type_ids": token_type_ids,
         }







@require_torch
class 							_lowerCAmelCase(			UpperCAmelCase_				,      unittest.TestCase   ):





       """simple docstring"""







       def      _a       (   self				):
         UpperCamelCase_:   int        =							FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
             'hf-internal-testing/tiny-random-clip'    ,     'hf-internal-testing/tiny-bert'    ,     vision_from_pt=_lowerCamelCase    ,     text_from_pt=_lowerCamelCase    ,     )
         UpperCamelCase_:   Union[str, Any]        =							1_3
         UpperCamelCase_:   Optional[int]        =							floats_tensor(
             [
                 batch_size,
                 model.config.vision_config.num_channels,
                 model.config.vision_config.image_size,
                 model.config.vision_config.image_size,
             ]				)
         UpperCamelCase_:   Optional[Any]        =							ids_tensor([batch_size, 4]    ,     model.config.text_config.vocab_size				)
         UpperCamelCase_:   Any        =							random_attention_mask([batch_size, 4]				)
         UpperCamelCase_:   List[str]        =							{'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

         return model, inputs





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         UpperCamelCase_:   str        =							FlaxCLIPVisionModel(_lowerCamelCase				)
         UpperCamelCase_:   int        =							FlaxBertModel(_lowerCamelCase				)
         return vision_model, text_model





       def      _a       (   self				):
         UpperCamelCase_:   int        =							FlaxCLIPVisionModelTester(self				)
         UpperCamelCase_:   Tuple        =							FlaxBertModelTester(self				)
         UpperCamelCase_:   List[str]        =							clip_model_tester.prepare_config_and_inputs()
         UpperCamelCase_:   int        =							bert_model_tester.prepare_config_and_inputs()

         UpperCamelCase_ ,UpperCamelCase_:   Optional[int]        =							vision_config_and_inputs

         UpperCamelCase_ ,UpperCamelCase_ ,UpperCamelCase_ ,UpperCamelCase_:   Union[str, Any]        =							text_config_and_inputs

         # make sure that cross attention layers are added
         return {
             "text_config": text_config,
             "vision_config": vision_config,
             "pixel_values": pixel_values,
             "attention_mask": attention_mask,
             "input_ids": input_ids,
             "token_type_ids": token_type_ids,
         }







@require_flax
@require_vision
class 							_lowerCAmelCase(			unittest.TestCase   ):





       """simple docstring"""







       @slow
       def      _a       (   self				):
         UpperCamelCase_:   Optional[int]        =							FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian'    ,     logit_scale_init_value=1.0				)
         UpperCamelCase_:   Optional[Any]        =							VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian'				)

         UpperCamelCase_:   Dict        =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
         UpperCamelCase_:   Any        =							processor(
             text=['una foto di un gatto', 'una foto di un cane']    ,     images=_lowerCamelCase    ,     padding=_lowerCamelCase    ,     return_tensors='np'				)

         UpperCamelCase_:   Union[str, Any]        =							model(**_lowerCamelCase				)

         # verify the logits
         self.assertEqual(outputs.logits_per_image.shape    ,     (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])				)
         self.assertEqual(
             outputs.logits_per_text.shape    ,     (inputs.input_ids.shape[0], inputs.pixel_values.shape[0])    ,     )

         UpperCamelCase_:   str        =							np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]				)

         self.assertTrue(np.allclose(outputs.logits_per_image    ,     _lowerCamelCase    ,     atol=1e-3				)				)




import collections
import os
import re
from pathlib import Path


UpperCAmelCase_		 =					"""src/transformers"""


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

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:Optional[int]				)  ->     Any:
   if _re_test_backend.search(_snake_case				) is None:
      return None
   _A      =       [b[0] for b in _re_backend.findall(_snake_case				)]
   backends.sort()
   return "_and_".join(_snake_case				)

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:Any				)  ->     Any:
   with open(_snake_case	,   '''r'''	,   encoding='''utf-8'''	,   newline='''\n'''				) as f:
      _A      =       f.readlines()

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

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

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

   _A      =       {'''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.
      _A      =       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:
         _A      =       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

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

         _A      =       objects
      else:
         line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
   _A      =       []
   while (
       line_index < len(_snake_case				)
       and find_backend(lines[line_index]				) is None
       and not lines[line_index].startswith('''else'''				)
   ):
      _A      =       lines[line_index]
      _A      =       _re_import.search(_snake_case				)
      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

   _A      =       {'''none''': objects}
   # Let's continue with backend-specific objects
   while line_index < len(_snake_case				):
      # If the line is an if is_backend_available, we grab all objects associated.
      _A      =       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:
         _A      =       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

         _A      =       []
         # Until we unindent, add backend objects to the list
         while len(lines[line_index]				) <= 1 or lines[line_index].startswith(''' ''' * 8				):
            _A      =       lines[line_index]
            _A      =       _re_import.search(_snake_case				)
            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

         _A      =       objects
      else:
         line_index += 1

   return import_dict_objects, type_hint_objects

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:List[str]	,   _snake_case	:Dict				)  ->     Any:

   def find_duplicates(_snake_case	:Any				):
      return [k for k, v in collections.Counter(_snake_case				).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!"]

   _A      =       []
   for key in import_dict_objects.keys():
      _A      =       find_duplicates(import_dict_objects[key]				)
      if duplicate_imports:
         errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''				)
      _A      =       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]				)				):
         _A      =       '''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 	SCREAMING_SNAKE_CASE_							(	)  ->     int:
   _A      =       []
   for root, _, files in os.walk(_snake_case				):
      if "__init__.py" in files:
         _A      =       os.path.join(_snake_case	,   '''__init__.py'''				)
         _A      =       parse_init(_snake_case				)
         if objects is not None:
            _A      =       analyze_results(*_snake_case				)
            if len(_snake_case				) > 0:
               _A      =       F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
               failures.append('''\n'''.join(_snake_case				)				)
   if len(_snake_case				) > 0:
      raise ValueError('''\n\n'''.join(_snake_case				)				)

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


UpperCAmelCase_		 =					[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]

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

   _A      =       direct_transformers_import(_snake_case				)

   _A      =       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(_snake_case	,   '''__init__.py'''				)	,   '''r'''				) as f:
      _A      =       f.read()
   import_structure_keys.update(set(re.findall(r'''import_structure\[\"([^\"]*)\"\]'''	,   _snake_case				)				)				)

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

   if len(_snake_case				) > 0:
      _A      =       '''\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()



