

import collections
import os
import re
from pathlib import Path


_SCREAMING_SNAKE_CASE					:  Tuple             =      '''src/transformers'''


# Matches is_xxx_available()
_SCREAMING_SNAKE_CASE					:  str             =      re.compile(r'''is\_([a-z_]*)_available()''')
# Catches a one-line _import_struct = {xxx}
_SCREAMING_SNAKE_CASE					:  Optional[int]             =      re.compile(r'''^_import_structure\s+=\s+\{([^\}]+)\}''')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
_SCREAMING_SNAKE_CASE					:  List[Any]             =      re.compile(r'''\s+\"\S*\":\s+\[([^\]]*)\]''')
# Catches a line if not is_foo_available
_SCREAMING_SNAKE_CASE					:  Any             =      re.compile(r'''^\s*if\s+not\s+is\_[a-z_]*\_available\(\)''')
# Catches a line _import_struct["bla"].append("foo")
_SCREAMING_SNAKE_CASE					:  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					:  Optional[Any]             =      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					:  List[Any]             =      re.compile(r'''^\s+\"([^\"]+)\",''')
# Catches a line with objects between brackets only:    ["foo", "bar"],
_SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      re.compile(r'''^\s+\[([^\]]+)\]''')
# Catches a line with from foo import bar, bla, boo
_SCREAMING_SNAKE_CASE					:  Any             =      re.compile(r'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
# Catches a line with try:
_SCREAMING_SNAKE_CASE					:  Any             =      re.compile(r'''^\s*try:''')
# Catches a line with else:
_SCREAMING_SNAKE_CASE					:  Dict             =      re.compile(r'''^\s*else:''')
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     if _re_test_backend.search(UpperCamelCase__    ) is None:
          return None
     SCREAMING_SNAKE_CASE__   =   [b[0] for b in _re_backend.findall(UpperCamelCase__    )]
     backends.sort()
     return "_and_".join(UpperCamelCase__    )
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     with open(UpperCamelCase__				,		'''r'''				,		encoding='''utf-8'''				,		newline='''\n'''    ) as f:
          SCREAMING_SNAKE_CASE__   =   f.readlines()

     SCREAMING_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
     SCREAMING_SNAKE_CASE__   =   []
     while not lines[line_index].startswith('''if TYPE_CHECKING'''    ) and find_backend(lines[line_index]    ) is None:
          SCREAMING_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__    ):
               SCREAMING_SNAKE_CASE__   =   _re_one_line_import_struct.search(UpperCamelCase__    ).groups()[0]
               SCREAMING_SNAKE_CASE__   =   re.findall(R'''\[([^\]]+)\]'''				,		UpperCamelCase__    )
               for imp in imports:
                    objects.extend([obj[1:-1] for obj in imp.split(''', '''    )]    )
               line_index += 1
               continue
          SCREAMING_SNAKE_CASE__   =   _re_import_struct_key_value.search(UpperCamelCase__    )
          if single_line_import_search is not None:
               SCREAMING_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

     SCREAMING_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.
          SCREAMING_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:
               SCREAMING_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

               SCREAMING_SNAKE_CASE__   =   []
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]    ) <= 1 or lines[line_index].startswith(''' ''' * 4    ):
                    SCREAMING_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:
                         SCREAMING_SNAKE_CASE__   =   _re_import_struct_add_many.search(UpperCamelCase__    ).groups()[0].split(''', '''    )
                         SCREAMING_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:
                         SCREAMING_SNAKE_CASE__   =   _re_between_brackets.search(UpperCamelCase__    ).groups()[0].split(''', '''    )
                         SCREAMING_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

               SCREAMING_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
     SCREAMING_SNAKE_CASE__   =   []
     while (
         line_index < len(UpperCamelCase__    )
         and find_backend(lines[line_index]    ) is None
         and not lines[line_index].startswith('''else'''    )
     ):
          SCREAMING_SNAKE_CASE__   =   lines[line_index]
          SCREAMING_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

     SCREAMING_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.
          SCREAMING_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:
               SCREAMING_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

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

               SCREAMING_SNAKE_CASE__   =   objects
          else:
               line_index += 1

     return import_dict_objects, type_hint_objects
def     UpperCAmelCase_       (						_A				,		_A    ):





     '''simple docstring'''




     def find_duplicates(_A    ):
          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!"]

     SCREAMING_SNAKE_CASE__   =   []
     for key in import_dict_objects.keys():
          SCREAMING_SNAKE_CASE__   =   find_duplicates(import_dict_objects[key]    )
          if duplicate_imports:
               errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''    )
          SCREAMING_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]    )    ):
               SCREAMING_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     UpperCAmelCase_       (						):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   []
     for root, _, files in os.walk(UpperCamelCase__    ):
          if "__init__.py" in files:
               SCREAMING_SNAKE_CASE__   =   os.path.join(UpperCamelCase__				,		'''__init__.py'''    )
               SCREAMING_SNAKE_CASE__   =   parse_init(UpperCamelCase__    )
               if objects is not None:
                    SCREAMING_SNAKE_CASE__   =   analyze_results(*UpperCamelCase__    )
                    if len(UpperCamelCase__    ) > 0:
                         SCREAMING_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     UpperCAmelCase_       (						):





     '''simple docstring'''




     SCREAMING_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
               SCREAMING_SNAKE_CASE__   =   str((Path(UpperCamelCase__    ) / folder).relative_to(UpperCamelCase__    )    )
               SCREAMING_SNAKE_CASE__   =   short_path.replace(os.path.sep				,		'''.'''    )
               submodules.append(UpperCamelCase__    )
          for fname in files:
               if fname == "__init__.py":
                    continue
               SCREAMING_SNAKE_CASE__   =   str((Path(UpperCamelCase__    ) / fname).relative_to(UpperCamelCase__    )    )
               SCREAMING_SNAKE_CASE__   =   short_path.replace('''.py'''				,		''''''    ).replace(os.path.sep				,		'''.'''    )
               if len(submodule.split('''.'''    )    ) == 1:
                    submodules.append(UpperCamelCase__    )
     return submodules


_SCREAMING_SNAKE_CASE					:  int             =      [
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
    '''models.esm.openfold_utils''',
]
def     UpperCAmelCase_       (						):





     '''simple docstring'''




     from transformers.utils import direct_transformers_import

     SCREAMING_SNAKE_CASE__   =   direct_transformers_import(UpperCamelCase__    )

     SCREAMING_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:
          SCREAMING_SNAKE_CASE__   =   f.read()
     import_structure_keys.update(set(re.findall(R'''import_structure\[\"([^\"]*)\"\]'''				,		UpperCamelCase__    )    )    )

     SCREAMING_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:
          SCREAMING_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()





from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE					:  Any             =      logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE					:  Optional[Any]             =      {
    '''google/vivit-b-16x2-kinetics400''': (
        '''https://huggingface.co/google/vivit-b-16x2-kinetics400/resolve/main/config.json'''
    ),
    # See all Vivit models at https://huggingface.co/models?filter=vivit
}






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= "vivit"






  def __init__(							self						:		str     ,       __lowerCamelCase						:		List[Any]=224     ,       __lowerCamelCase						:		Optional[int]=32     ,       __lowerCamelCase						:		Tuple=[2, 16, 16]     ,       __lowerCamelCase						:		Union[str, Any]=3     ,       __lowerCamelCase						:		Optional[Any]=768     ,       __lowerCamelCase						:		Any=12     ,       __lowerCamelCase						:		Optional[Any]=12     ,       __lowerCamelCase						:		List[str]=3072     ,       __lowerCamelCase						:		Any="gelu_fast"     ,       __lowerCamelCase						:		Union[str, Any]=0.0     ,       __lowerCamelCase						:		int=0.0     ,       __lowerCamelCase						:		str=0.02     ,       __lowerCamelCase						:		Any=1e-06     ,       __lowerCamelCase						:		Dict=True     ,       **__lowerCamelCase						:		Any     ,       )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   hidden_size
       SCREAMING_SNAKE_CASE__   =   num_hidden_layers
       SCREAMING_SNAKE_CASE__   =   num_attention_heads
       SCREAMING_SNAKE_CASE__   =   intermediate_size
       SCREAMING_SNAKE_CASE__   =   hidden_act
       SCREAMING_SNAKE_CASE__   =   hidden_dropout_prob
       SCREAMING_SNAKE_CASE__   =   attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__   =   initializer_range
       SCREAMING_SNAKE_CASE__   =   layer_norm_eps

       SCREAMING_SNAKE_CASE__   =   image_size
       SCREAMING_SNAKE_CASE__   =   num_frames
       SCREAMING_SNAKE_CASE__   =   tubelet_size
       SCREAMING_SNAKE_CASE__   =   num_channels
       SCREAMING_SNAKE_CASE__   =   qkv_bias

       super().__init__(**__lowerCamelCase )


