

"""simple docstring"""





import os
import re
import shutil
import sys
import tempfile
import unittest

import black


__UpperCamelCase  :      int							      =		os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, '''utils'''))

import check_copies  # noqa: E402


# This is the reference code that will be used in the tests.
# If BertLMPredictionHead is changed in modeling_bert.py, this code needs to be manually updated.
__UpperCamelCase  :      Dict							      =		'''    def __init__(self, config):
        super().__init__()
        self.transform = BertPredictionHeadTransform(config)

        # The output weights are the same as the input embeddings, but there is
        # an output-only bias for each token.
        self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)

        self.bias = nn.Parameter(torch.zeros(config.vocab_size))

        # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
        self.decoder.bias = self.bias

    def forward(self, hidden_states):
        hidden_states = self.transform(hidden_states)
        hidden_states = self.decoder(hidden_states)
        return hidden_states
'''







class 				SCREAMING_SNAKE_CASE					(		unittest.TestCase       ):






					"""simple docstring"""



					def        __lowerCAmelCase (       self			:				Dict		):
						lowerCAmelCase__	:						Optional[Any]  				=	tempfile.mkdtemp()
						os.makedirs(os.path.join(self.transformer_dir   ,'''models/bert/'''		)		)
						lowerCAmelCase__	:						int  				=	self.transformer_dir
						shutil.copy(
						    os.path.join(lowercase_   ,'''src/transformers/models/bert/modeling_bert.py'''		)   ,os.path.join(self.transformer_dir   ,'''models/bert/modeling_bert.py'''		)   ,)







					def        __lowerCAmelCase (       self			:				str		):
						lowerCAmelCase__	:						Tuple  				=	'''src/transformers'''
						shutil.rmtree(self.transformer_dir		)







					def        __lowerCAmelCase (       self			:				Optional[int]   ,lowercase_			:				Tuple   ,lowercase_			:				List[str]   ,lowercase_			:				List[str]   ,lowercase_			:				Any=None		):
						lowerCAmelCase__	:						Any  				=	comment + F'\nclass {class_name}(nn.Module):\n' + class_code
						if overwrite_result is not None:
							lowerCAmelCase__	:						str  				=	comment + F'\nclass {class_name}(nn.Module):\n' + overwrite_result
						lowerCAmelCase__	:						str  				=	black.Mode(target_versions={black.TargetVersion.PYaa}   ,line_length=1_1_9		)
						lowerCAmelCase__	:						Union[str, Any]  				=	black.format_str(lowercase_   ,mode=lowercase_		)
						lowerCAmelCase__	:						Any  				=	os.path.join(self.transformer_dir   ,'''new_code.py'''		)
						with open(lowercase_   ,'''w'''   ,newline='''\n'''		) as f:
							f.write(lowercase_		)
						if overwrite_result is None:
							self.assertTrue(len(check_copies.is_copy_consistent(lowercase_		)		) == 0		)
						else:
							check_copies.is_copy_consistent(f.name   ,overwrite=lowercase_		)
							with open(lowercase_   ,'''r'''		) as f:
								self.assertTrue(f.read()   ,lowercase_		)







					def        __lowerCAmelCase (       self			:				List[Any]		):
						lowerCAmelCase__	:						List[Any]  				=	check_copies.find_code_in_transformers('''models.bert.modeling_bert.BertLMPredictionHead'''		)
						self.assertEqual(lowercase_   ,lowercase_		)







					def        __lowerCAmelCase (       self			:				Union[str, Any]		):
						# Base copy consistency
						self.check_copy_consistency(
						    '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead'''   ,'''BertLMPredictionHead'''   ,REFERENCE_CODE + '''\n'''   ,)

						# With no empty line at the end
						self.check_copy_consistency(
						    '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead'''   ,'''BertLMPredictionHead'''   ,lowercase_   ,)

						# Copy consistency with rename
						self.check_copy_consistency(
						    '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel'''   ,'''TestModelLMPredictionHead'''   ,re.sub('''Bert'''   ,'''TestModel'''   ,lowercase_		)   ,)

						# Copy consistency with a really long name
						lowerCAmelCase__	:						List[Any]  				=	'''TestModelWithAReallyLongNameBecauseSomePeopleLikeThatForSomeReason'''
						self.check_copy_consistency(
						    F'# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->{long_class_name}'   ,F'{long_class_name}LMPredictionHead'   ,re.sub('''Bert'''   ,lowercase_   ,lowercase_		)   ,)

						# Copy consistency with overwrite
						self.check_copy_consistency(
						    '''# Copied from transformers.models.bert.modeling_bert.BertLMPredictionHead with Bert->TestModel'''   ,'''TestModelLMPredictionHead'''   ,lowercase_   ,overwrite_result=re.sub('''Bert'''   ,'''TestModel'''   ,lowercase_		)   ,)







					def        __lowerCAmelCase (       self			:				Tuple		):
						lowerCAmelCase__	:						List[str]  				=	check_copies.LOCALIZED_READMES['''README_zh-hans.md''']

						lowerCAmelCase__	:						str  				=	(
						    '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'''
						    ''' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'''
						    ''' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'''
						    ''' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.\n1.'''
						    ''' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (from HuggingFace),'''
						    ''' released together with the paper [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'''
						    ''' lighter](https://arxiv.org/abs/1910.01108) by Victor Sanh, Lysandre Debut and Thomas Wolf. The same'''
						    ''' method has been applied to compress GPT2 into'''
						    ''' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'''
						    ''' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'''
						    ''' Multilingual BERT into'''
						    ''' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'''
						    ''' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)**'''
						    ''' (from Google Research/Stanford University) released with the paper [ELECTRA: Pre-training text encoders'''
						    ''' as discriminators rather than generators](https://arxiv.org/abs/2003.10555) by Kevin Clark, Minh-Thang'''
						    ''' Luong, Quoc V. Le, Christopher D. Manning.'''
						)
						lowerCAmelCase__	:						Union[str, Any]  				=	(
						    '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
						    ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
						    ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
						    ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
						)
						lowerCAmelCase__	:						int  				=	(
						    '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
						    ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
						    ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
						    ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n1.'''
						    ''' **[DistilBERT](https://huggingface.co/transformers/model_doc/distilbert.html)** (来自 HuggingFace) 伴随论文'''
						    ''' [DistilBERT, a distilled version of BERT: smaller, faster, cheaper and'''
						    ''' lighter](https://arxiv.org/abs/1910.01108) 由 Victor Sanh, Lysandre Debut and Thomas Wolf 发布。 The same'''
						    ''' method has been applied to compress GPT2 into'''
						    ''' [DistilGPT2](https://github.com/huggingface/transformers/tree/main/examples/distillation), RoBERTa into'''
						    ''' [DistilRoBERTa](https://github.com/huggingface/transformers/tree/main/examples/distillation),'''
						    ''' Multilingual BERT into'''
						    ''' [DistilmBERT](https://github.com/huggingface/transformers/tree/main/examples/distillation) and a German'''
						    ''' version of DistilBERT.\n1. **[ELECTRA](https://huggingface.co/transformers/model_doc/electra.html)** (来自'''
						    ''' Google Research/Stanford University) 伴随论文 [ELECTRA: Pre-training text encoders as discriminators rather'''
						    ''' than generators](https://arxiv.org/abs/2003.10555) 由 Kevin Clark, Minh-Thang Luong, Quoc V. Le,'''
						    ''' Christopher D. Manning 发布。\n'''
						)

						lowerCAmelCase__				,lowerCAmelCase__	:						Optional[Any]  				=	check_copies.convert_to_localized_md(
						    lowercase_   ,lowercase_   ,localized_readme['''format_model_list''']		)

						self.assertFalse(lowercase_		)
						self.assertEqual(lowercase_   ,lowercase_		)

						lowerCAmelCase__				,lowerCAmelCase__	:						int  				=	check_copies.convert_to_localized_md(
						    lowercase_   ,lowercase_   ,localized_readme['''format_model_list''']		)

						# Check whether the number of models is equal to README.md after conversion.
						self.assertTrue(lowercase_		)

						lowerCAmelCase__	:						List[str]  				=	(
						    '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (from Google Research and the'''
						    ''' Toyota Technological Institute at Chicago) released with the paper [ALBERT: A Lite BERT for'''
						    ''' Self-supervised Learning of Language Representations](https://arxiv.org/abs/1909.11942), by Zhenzhong'''
						    ''' Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.'''
						)
						lowerCAmelCase__	:						Optional[int]  				=	(
						    '''1. **[ALBERT](https://huggingface.co/transformers/main/model_doc/albert.html)** (来自 Google Research and'''
						    ''' the Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
						    ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
						    ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
						)
						lowerCAmelCase__	:						str  				=	(
						    '''1. **[ALBERT](https://huggingface.co/transformers/model_doc/albert.html)** (来自 Google Research and the'''
						    ''' Toyota Technological Institute at Chicago) 伴随论文 [ALBERT: A Lite BERT for Self-supervised Learning of'''
						    ''' Language Representations](https://arxiv.org/abs/1909.11942), 由 Zhenzhong Lan, Mingda Chen, Sebastian'''
						    ''' Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut 发布。\n'''
						)

						lowerCAmelCase__				,lowerCAmelCase__	:						Any  				=	check_copies.convert_to_localized_md(
						    lowercase_   ,lowercase_   ,localized_readme['''format_model_list''']		)

						# Check if the model link is synchronized.
						self.assertEqual(lowercase_   ,lowercase_		)






"""simple docstring"""




import math
import unittest

def lowercase_  (   _snake_case						):
							assert isinstance(_snake_case   ,_snake_case						) and (
							    number >= 0
							), "'number' must been an int and positive"

							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5   ,int(math.sqrt(_snake_case						) + 1						)   ,6						):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True



class 	lowerCAmelCase_						(unittest.TestCase  ):


				"""simple docstring"""



				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											self.assertTrue(is_prime(2    )    )
											self.assertTrue(is_prime(3    )    )
											self.assertTrue(is_prime(5    )    )
											self.assertTrue(is_prime(7    )    )
											self.assertTrue(is_prime(11    )    )
											self.assertTrue(is_prime(13    )    )
											self.assertTrue(is_prime(17    )    )
											self.assertTrue(is_prime(19    )    )
											self.assertTrue(is_prime(23    )    )
											self.assertTrue(is_prime(29    )    )



				def 	__magic_name__    (self    )					->		List[Any]:



											"""simple docstring"""




											with self.assertRaises(SCREAMING_SNAKE_CASE__    ):
																		is_prime(-19    )
											self.assertFalse(
											    is_prime(0    )   ,       """Zero doesn't have any positive factors, primes must have exactly two."""   ,       )
											self.assertFalse(
											    is_prime(1    )   ,       """One only has 1 positive factor, primes must have exactly two."""   ,       )
											self.assertFalse(is_prime(2 * 2    )    )
											self.assertFalse(is_prime(2 * 3    )    )
											self.assertFalse(is_prime(3 * 3    )    )
											self.assertFalse(is_prime(3 * 5    )    )
											self.assertFalse(is_prime(3 * 5 * 7    )    )


if __name__ == "__main__":
					unittest.main()




