




"""simple docstring"""
import argparse
import os
import re

import packaging.version


a_				:    str										=     '''examples/'''
a_				:    List[str]										=     {
    '''examples''': (re.compile(R'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''),
    '''init''': (re.compile(R'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''),
    '''setup''': (re.compile(R'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), R'''\1version="VERSION",'''),
    '''doc''': (re.compile(R'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''),
}
a_				:    Tuple										=     {
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
a_				:    List[Any]										=     '''README.md'''





def 						UpperCAmelCase				(			A__:    Any							,				A__:    List[str]							,				A__:    Union[str, Any]     )  ->     str:
			with open(A__							,				'r'							,				encoding='utf-8'							,				newline='\n'     ) as f:
						__lowerCamelCase					:	Dict	       =				f.read()
			__lowerCamelCase       ,      __lowerCamelCase					:	Dict	       =				REPLACE_PATTERNS[pattern]
			__lowerCamelCase					:	str	       =				replace.replace('VERSION'							,				A__     )
			__lowerCamelCase					:	int	       =				re_pattern.sub(A__							,				A__     )
			with open(A__							,				'w'							,				encoding='utf-8'							,				newline='\n'     ) as f:
						f.write(A__     )





def 						UpperCAmelCase				(			A__:    Optional[int]     )  ->     Tuple:
			for folder, directories, fnames in os.walk(A__     ):
						# Removing some of the folders with non-actively maintained examples from the walk
						if "research_projects" in directories:
									directories.remove('research_projects'     )
						if "legacy" in directories:
									directories.remove('legacy'     )
						for fname in fnames:
									if fname.endswith('.py'     ):
												update_version_in_file(os.path.join(A__							,				A__     )							,				A__							,				pattern='examples'     )





def 						UpperCAmelCase				(			A__:    Tuple							,				A__:    int=False     )  ->     Dict:
			for pattern, fname in REPLACE_FILES.items():
						update_version_in_file(A__							,				A__							,				A__     )
			if not patch:
						update_version_in_examples(A__     )





def 						UpperCAmelCase				(			)  ->     Optional[Any]:
			__lowerCamelCase					:	str	       =				'🤗 Transformers currently provides the following architectures'
			__lowerCamelCase					:	Optional[Any]	       =				'1. Want to contribute a new model?'
			with open(A__							,				'r'							,				encoding='utf-8'							,				newline='\n'     ) as f:
						__lowerCamelCase					:	Optional[Any]	       =				f.readlines()

			# Find the start of the list.
			__lowerCamelCase					:	Optional[Any]	       =				0
			while not lines[start_index].startswith(_start_prompt     ):
						start_index += 1
			start_index += 1

			__lowerCamelCase					:	Optional[Any]	       =				start_index
			# Update the lines in the model list.
			while not lines[index].startswith(_end_prompt     ):
						if lines[index].startswith('1.'     ):
									__lowerCamelCase					:	Union[str, Any]	       =				lines[index].replace(
									    'https://huggingface.co/docs/transformers/main/model_doc'							,				'https://huggingface.co/docs/transformers/model_doc'							,				)
						index += 1

			with open(A__							,				'w'							,				encoding='utf-8'							,				newline='\n'     ) as f:
						f.writelines(A__     )





def 						UpperCAmelCase				(			)  ->     Dict:
			with open(REPLACE_FILES['init']							,				'r'     ) as f:
						__lowerCamelCase					:	int	       =				f.read()
			__lowerCamelCase					:	str	       =				REPLACE_PATTERNS['init'][0].search(A__     ).groups()[0]
			return packaging.version.parse(A__     )





def 						UpperCAmelCase				(			A__:    List[Any]=False     )  ->     Optional[int]:
			__lowerCamelCase					:	List[Any]	       =				get_version()
			if patch and default_version.is_devrelease:
						raise ValueError('Can\'t create a patch version from the dev branch, checkout a released version!'     )
			if default_version.is_devrelease:
						__lowerCamelCase					:	int	       =				default_version.base_version
			elif patch:
						__lowerCamelCase					:	int	       =				f'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
			else:
						__lowerCamelCase					:	int	       =				f'''{default_version.major}.{default_version.minor + 1}.0'''

			# Now let's ask nicely if that's the right one.
			__lowerCamelCase					:	List[str]	       =				input(f'''Which version are you releasing? [{default_version}]'''     )
			if len(A__     ) == 0:
						__lowerCamelCase					:	str	       =				default_version

			print(f'''Updating version to {version}.'''     )
			global_version_update(A__							,				patch=A__     )
			if not patch:
						print('Cleaning main README, don\'t forget to run `make fix-copies`.'     )
						clean_main_ref_in_model_list()





def 						UpperCAmelCase				(			)  ->     Any:
			__lowerCamelCase					:	List[Any]	       =				get_version()
			__lowerCamelCase					:	Optional[Any]	       =				f'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
			__lowerCamelCase					:	int	       =				current_version.base_version

			# Check with the user we got that right.
			__lowerCamelCase					:	List[str]	       =				input(f'''Which version are we developing now? [{dev_version}]'''     )
			if len(A__     ) == 0:
						__lowerCamelCase					:	List[str]	       =				dev_version

			print(f'''Updating version to {version}.'''     )
			global_version_update(A__     )
			print('Cleaning main README, don\'t forget to run `make fix-copies`.'     )
			clean_main_ref_in_model_list()


if __name__ == "__main__":
					a_				:    Dict										=     argparse.ArgumentParser()
					parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''')
					parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''')
					a_				:    int										=     parser.parse_args()
					if not args.post_release:
										pre_release_work(patch=args.patch)
					elif args.patch:
										print('''Nothing to do after a patch :-)''')
					else:
										post_release_work()









"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


a_				:    Tuple										=     logging.get_logger(__name__)

a_				:    str										=     {'''openai-gpt''': '''https://huggingface.co/openai-gpt/resolve/main/config.json'''}

class __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						Union[str, Any]     		= 'openai-gpt'
					__a						:						List[Any]     		= {
					    'max_position_embeddings': 'n_positions',
					    'hidden_size': 'n_embd',
					    'num_attention_heads': 'n_head',
					    'num_hidden_layers': 'n_layer',
					}
					def __init__(    self						,	__a=40478						,	__a=512						,	__a=768						,	__a=12						,	__a=12						,	__a="gelu"						,	__a=0.1						,	__a=0.1						,	__a=0.1						,	__a=1E-5						,	__a=0.02						,	__a="cls_index"						,	__a=True						,	__a=None						,	__a=True						,	__a=0.1						,	**__a						,	):
								__lowerCamelCase					:	List[str]	       =				vocab_size
								__lowerCamelCase					:	Union[str, Any]	       =				n_positions
								__lowerCamelCase					:	Optional[Any]	       =				n_embd
								__lowerCamelCase					:	int	       =				n_layer
								__lowerCamelCase					:	List[str]	       =				n_head
								__lowerCamelCase					:	Dict	       =				afn
								__lowerCamelCase					:	Optional[Any]	       =				resid_pdrop
								__lowerCamelCase					:	int	       =				embd_pdrop
								__lowerCamelCase					:	int	       =				attn_pdrop
								__lowerCamelCase					:	Dict	       =				layer_norm_epsilon
								__lowerCamelCase					:	List[str]	       =				initializer_range
								__lowerCamelCase					:	Any	       =				summary_type
								__lowerCamelCase					:	Tuple	       =				summary_use_proj
								__lowerCamelCase					:	List[Any]	       =				summary_activation
								__lowerCamelCase					:	str	       =				summary_first_dropout
								__lowerCamelCase					:	Tuple	       =				summary_proj_to_labels
								super().__init__(**__a     )



