


import collections
import importlib.util
import os
import re
from pathlib import Path


UpperCAmelCase_				:			int   =	'src/transformers'


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







def 	SCREAMING_SNAKE_CASE_						(      __A			:      List[str]    )     ->		Tuple:

       """simple docstring"""

       if _re_test_backend.search(__A    ) is None:
              return None
       a_ :		Optional[int]							=  [b[0] for b in _re_backend.findall(__A    )]
       backends.sort()
       return "_and_".join(__A    )







def 	SCREAMING_SNAKE_CASE_						(      __A			:      str    )     ->		Any:

       """simple docstring"""

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

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

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

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

       a_ :		Tuple							=  {'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_ :		List[str]							=  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_ :		List[str]							=  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_ :		Dict							=  []
                     # Until we unindent, add backend objects to the list
                     while len(lines[line_index]    ) <= 1 or lines[line_index].startswith(' ' * 4    ):
                            a_ :		List[Any]							=  lines[line_index]
                            if _re_import_struct_add_one.search(__A    ) is not None:
                                   objects.append(_re_import_struct_add_one.search(__A    ).groups()[0]    )
                            elif _re_import_struct_add_many.search(__A    ) is not None:
                                   a_ :		int							=  _re_import_struct_add_many.search(__A    ).groups()[0].split(', '    )
                                   a_ :		List[str]							=  [obj[1:-1] for obj in imports if len(__A    ) > 0]
                                   objects.extend(__A    )
                            elif _re_between_brackets.search(__A    ) is not None:
                                   a_ :		Tuple							=  _re_between_brackets.search(__A    ).groups()[0].split(', '    )
                                   a_ :		Dict							=  [obj[1:-1] for obj in imports if len(__A    ) > 0]
                                   objects.extend(__A    )
                            elif _re_quote_object.search(__A    ) is not None:
                                   objects.append(_re_quote_object.search(__A    ).groups()[0]    )
                            elif line.startswith(' ' * 8 + '"'    ):
                                   objects.append(line[9:-3]    )
                            elif line.startswith(' ' * 12 + '"'    ):
                                   objects.append(line[13:-3]    )
                            line_index += 1

                     a_ :		Union[str, Any]							=  objects
              else:
                     line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
       a_ :		List[str]							=  []
       while (
           line_index < len(__A    )
           and find_backend(lines[line_index]    ) is None
           and not lines[line_index].startswith('else'    )
       ):
              a_ :		int							=  lines[line_index]
              a_ :		Any							=  _re_import.search(__A    )
              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_ :		Optional[Any]							=  {'none': objects}
       # Let's continue with backend-specific objects
       while line_index < len(__A    ):
              # If the line is an if is_backend_available, we grab all objects associated.
              a_ :		Any							=  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_ :		List[str]							=  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_ :		Union[str, Any]							=  []
                     # Until we unindent, add backend objects to the list
                     while len(lines[line_index]    ) <= 1 or lines[line_index].startswith(' ' * 8    ):
                            a_ :		Optional[Any]							=  lines[line_index]
                            a_ :		Dict							=  _re_import.search(__A    )
                            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_ :		int							=  objects
              else:
                     line_index += 1

       return import_dict_objects, type_hint_objects







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

       """simple docstring"""

       def find_duplicates(__A			:      Optional[int]    ):
              return [k for k, v in collections.Counter(__A    ).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_ :		List[Any]							=  []
       for key in import_dict_objects.keys():
              a_ :		List[str]							=  find_duplicates(import_dict_objects[key]    )
              if duplicate_imports:
                     errors.append(F"""Duplicate _import_structure definitions for: {duplicate_imports}"""    )
              a_ :		int							=  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_ :		Union[str, Any]							=  '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_						(      )     ->		Any:

       """simple docstring"""

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







def 	SCREAMING_SNAKE_CASE_						(      )     ->		int:

       """simple docstring"""

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


UpperCAmelCase_				:			List[str]   =	[
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]







def 	SCREAMING_SNAKE_CASE_						(      )     ->		Tuple:

       """simple docstring"""

       a_ :		Dict							=  importlib.util.spec_from_file_location(
           'transformers'  ,   os.path.join(__A  ,   '__init__.py'    )  ,   submodule_search_locations=[PATH_TO_TRANSFORMERS]  ,   )
       a_ :		List[Any]							=  spec.loader.load_module()

       a_ :		Any							=  [
           module
           for module in get_transformers_submodules()
           if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
       ]
       if len(__A    ) > 0:
              a_ :		int							=  '\n'.join(F"""- {module}""" for module in module_not_registered    )
              raise ValueError(
                  'The following submodules are not properly registered 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()






import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
   import torch

   from transformers.activations import gelu_new, gelu_python, get_activation
@require_torch
class 			SCREAMING_SNAKE_CASE__  (    unittest.TestCase      ):
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					)		->      List[str]:
             a_ :		List[str]							=  torch.tensor([-1_0_0, -1, -0.1, 0, 0.1, 1.0, 1_0_0]					)
             a_ :		Union[str, Any]							=  get_activation('gelu'					)
             self.assertTrue(torch.allclose(gelu_python(SCREAMING_SNAKE_CASE__					)					,							torch_builtin(SCREAMING_SNAKE_CASE__					)					)					)
             self.assertFalse(torch.allclose(gelu_python(SCREAMING_SNAKE_CASE__					)					,							gelu_new(SCREAMING_SNAKE_CASE__					)					)					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Union[str, Any]					)		->      Any:
             a_ :		List[str]							=  torch.tensor([-1_0_0, -1, -0.1, 0, 0.1, 1.0, 1_0_0]					)
             a_ :		Union[str, Any]							=  get_activation('gelu'					)
             a_ :		str							=  get_activation('gelu_10'					)

             a_ :		Tuple							=  torch_builtin(SCREAMING_SNAKE_CASE__					)
             a_ :		str							=  geluaa(SCREAMING_SNAKE_CASE__					)

             a_ :		List[Any]							=  torch.where(y_gelu_aa < 10.0					,							1					,							0					)

             self.assertTrue(torch.max(SCREAMING_SNAKE_CASE__					).item() == 10.0					)
             self.assertTrue(torch.allclose(y_gelu * clipped_mask					,							y_gelu_aa * clipped_mask					)					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					)		->      List[Any]:
             get_activation('gelu'					)
             get_activation('gelu_10'					)
             get_activation('gelu_fast'					)
             get_activation('gelu_new'					)
             get_activation('gelu_python'					)
             get_activation('gelu_pytorch_tanh'					)
             get_activation('linear'					)
             get_activation('mish'					)
             get_activation('quick_gelu'					)
             get_activation('relu'					)
             get_activation('sigmoid'					)
             get_activation('silu'					)
             get_activation('swish'					)
             get_activation('tanh'					)
             with self.assertRaises(SCREAMING_SNAKE_CASE__					):
                    get_activation('bogus'					)
             with self.assertRaises(SCREAMING_SNAKE_CASE__					):
                    get_activation(SCREAMING_SNAKE_CASE__					)

      def 	SCREAMING_SNAKE_CASE							(	self    :	str					)		->      str:
             a_ :		Any							=  get_activation('gelu'					)
             a_ :		Any							=  1
             a_ :		int							=  get_activation('gelu'					)
             self.assertEqual(acta.a					,							1					)
             with self.assertRaises(SCREAMING_SNAKE_CASE__					):
                    a_ :		Tuple							=  acta.a


