


'''simple docstring'''
import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
__SCREAMING_SNAKE_CASE				:							Tuple		       =		'''src/transformers'''

# Matches is_xxx_available()
__SCREAMING_SNAKE_CASE				:							str		       =		re.compile(r'''is\_([a-z_]*)_available()''')
# Matches from xxx import bla
__SCREAMING_SNAKE_CASE				:							Union[str, Any]		       =		re.compile(r'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
__SCREAMING_SNAKE_CASE				:							Union[str, Any]		       =		re.compile(r'''^\s+if\s+not\s+\(?is\_[a-z_]*\_available\(\)''')


__SCREAMING_SNAKE_CASE				:							str		       =		'''
{0} = None
'''

__SCREAMING_SNAKE_CASE				:							Optional[Any]		       =		'''
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})
'''


__SCREAMING_SNAKE_CASE				:							int		       =		'''
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
'''







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







def 			a_							(  ):
							with open(os.path.join(UpperCamelCase_	,     "__init__.py"   )	,     "r"	,     encoding="utf-8"	,     newline="\n"   ) as f:
														A_ 						=		f.readlines()

							# Get to the point we do the actual imports for type checking
							A_ 						=		0
							while not lines[line_index].startswith("if TYPE_CHECKING"   ):
														line_index += 1

							A_ 						=		{}
							# Go through the end of the file
							while line_index < len(UpperCamelCase_   ):
														# If the line is an if is_backend_available, we grab all objects associated.
														A_ 						=		find_backend(lines[line_index]   )
														if backend is not None:
																					while not lines[line_index].startswith("    else:"   ):
																												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_single_line_import.search(UpperCamelCase_   )
																												if single_line_import_search is not None:
																																			objects.extend(single_line_import_search.groups()[0].split(", "   )   )
																												elif line.startswith(" " * 1_2   ):
																																			objects.append(line[1_2:-2]   )
																												line_index += 1

																					A_ 						=		objects
														else:
																					line_index += 1

							return backend_specific_objects







def 			a_							(  UpperCamelCase_	,     UpperCamelCase_   ):
							if name.isupper():
														return DUMMY_CONSTANT.format(UpperCamelCase_   )
							elif name.islower():
														return DUMMY_FUNCTION.format(UpperCamelCase_	,     UpperCamelCase_   )
							else:
														return DUMMY_CLASS.format(UpperCamelCase_	,     UpperCamelCase_   )







def 			a_							(  UpperCamelCase_=None   ):
							if backend_specific_objects is None:
														A_ 						=		read_init()
							# For special correspondence backend to module name as used in the function requires_modulename
							A_ 						=		{}

							for backend, objects in backend_specific_objects.items():
														A_ 						=		"[" + ", ".join(f"\"{b}\"" for b in backend.split("_and_"   )   ) + "]"
														A_ 						=		"# This file is autogenerated by the command `make fix-copies`, do not edit.\n"
														dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
														dummy_file += "\n".join([create_dummy_object(UpperCamelCase_	,     UpperCamelCase_   ) for o in objects]   )
														A_ 						=		dummy_file

							return dummy_files







def 			a_							(  UpperCamelCase_=False   ):
							A_ 						=		create_dummy_files()
							# For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
							A_ 						=		{"torch": "pt"}

							# Locate actual dummy modules and read their content.
							A_ 						=		os.path.join(UpperCamelCase_	,     "utils"   )
							A_ 						=		{
							    backend: os.path.join(UpperCamelCase_	,     f"dummy_{short_names.get(UpperCamelCase_	,     UpperCamelCase_   )}_objects.py"   )
							    for backend in dummy_files.keys()
							}

							A_ 						=		{}
							for backend, file_path in dummy_file_paths.items():
														if os.path.isfile(UpperCamelCase_   ):
																					with open(UpperCamelCase_	,     "r"	,     encoding="utf-8"	,     newline="\n"   ) as f:
																												A_ 						=		f.read()
														else:
																					A_ 						=		""

							for backend in dummy_files.keys():
														if dummy_files[backend] != actual_dummies[backend]:
																					if overwrite:
																												print(
																												    f"Updating transformers.utils.dummy_{short_names.get(UpperCamelCase_	,     UpperCamelCase_   )}_objects.py as the main "
																												    "__init__ has new objects."   )
																												with open(dummy_file_paths[backend]	,     "w"	,     encoding="utf-8"	,     newline="\n"   ) as f:
																																			f.write(dummy_files[backend]   )
																					else:
																												raise ValueError(
																												    "The main __init__ has objects that are not present in "
																												    f"transformers.utils.dummy_{short_names.get(UpperCamelCase_	,     UpperCamelCase_   )}_objects.py. Run `make fix-copies` "
																												    "to fix this."   )


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE				:							Optional[int]		       =		argparse.ArgumentParser()
							parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
							__SCREAMING_SNAKE_CASE				:							Optional[Any]		       =		parser.parse_args()

							check_dummies(args.fix_and_overwrite)









'''simple docstring'''
import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
							import tensorflow as tf

							from transformers.activations_tf import get_tf_activation






@require_tf
class 				__lowerCAmelCase      (      unittest.TestCase	):

						"""simple docstring"""






						def 							_UpperCAmelCase					(     self       :			List[Any]  ):
													A_ 						=		tf.constant([-1_00, -1.0, -0.1, 0, 0.1, 1.0, 1_0_0.0]  )
													A_ 						=		get_tf_activation("gelu"  )
													A_ 						=		get_tf_activation("gelu_10"  )

													A_ 						=		gelu(lowerCAmelCase  )
													A_ 						=		geluaa(lowerCAmelCase  )

													A_ 						=		tf.where(y_gelu_aa < 1_0.0   ,     1.0   ,     0.0  )

													self.assertEqual(tf.math.reduce_max(lowerCAmelCase  ).numpy().item()   ,     1_0.0  )
													self.assertTrue(np.allclose(y_gelu * clipped_mask   ,     y_gelu_aa * clipped_mask  )  )






						def 							_UpperCAmelCase					(     self       :			Union[str, Any]  ):
													get_tf_activation("gelu"  )
													get_tf_activation("gelu_10"  )
													get_tf_activation("gelu_fast"  )
													get_tf_activation("gelu_new"  )
													get_tf_activation("glu"  )
													get_tf_activation("mish"  )
													get_tf_activation("quick_gelu"  )
													get_tf_activation("relu"  )
													get_tf_activation("sigmoid"  )
													get_tf_activation("silu"  )
													get_tf_activation("swish"  )
													get_tf_activation("tanh"  )
													with self.assertRaises(lowerCAmelCase  ):
																				get_tf_activation("bogus"  )
													with self.assertRaises(lowerCAmelCase  ):
																				get_tf_activation(lowerCAmelCase  )





