'''simple docstring'''


import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCAmelCase	:       List[str]						       =	logging.get_logger(__name__)





def       lowerCAmelCase					(		UpperCamelCase__				:   Dict    ,					UpperCamelCase__				:   List[str]    ,					UpperCamelCase__				:   str       ):


	"""simple docstring"""
	__UpperCAmelCase							=			os.path.abspath(UpperCamelCase__       )
	logger.info(f"""Converting TensorFlow checkpoint from {tf_path}"""       )
	# Load weights from TF model
	__UpperCAmelCase							=			tf.train.list_variables(UpperCamelCase__       )
	__UpperCAmelCase							=			[]
	__UpperCAmelCase							=			[]
	__UpperCAmelCase							=			[]
	for full_name, shape in init_vars:
		# logger.info(f"Loading TF weight {name} with shape {shape}")
		__UpperCAmelCase							=			full_name.split('''/'''       )
		if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
			logger.info(f"""Skipping non-model layer {full_name}"""       )
			continue
		if "optimizer" in full_name:
			logger.info(f"""Skipping optimization layer {full_name}"""       )
			continue
		if name[0] == "model":
			# ignore initial 'model'
			__UpperCAmelCase							=			name[1:]
		# figure out how many levels deep the name is
		__UpperCAmelCase							=			0
		for _name in name:
			if _name.startswith('''layer_with_weights'''       ):
				depth += 1
			else:
				break
		layer_depth.append(UpperCamelCase__       )
		# read data
		__UpperCAmelCase							=			tf.train.load_variable(UpperCamelCase__    ,					UpperCamelCase__       )
		names.append('''/'''.join(UpperCamelCase__       )       )
		arrays.append(UpperCamelCase__       )
	logger.info(f"""Read a total of {len(UpperCamelCase__       ):,} layers"""       )

	# Sanity check
	if len(set(UpperCamelCase__       )       ) != 1:
		raise ValueError(f"""Found layer names with different depths (layer depth {list(set(UpperCamelCase__       )       )})"""       )
	__UpperCAmelCase							=			list(set(UpperCamelCase__       )       )[0]
	if layer_depth != 1:
		raise ValueError(
		    '''The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP'''
		    ''' heads.'''       )

	# convert layers
	logger.info('''Converting weights...'''       )
	for full_name, array in zip(UpperCamelCase__    ,					UpperCamelCase__       ):
		__UpperCAmelCase							=			full_name.split('''/'''       )
		__UpperCAmelCase							=			model
		__UpperCAmelCase							=			[]
		for i, m_name in enumerate(UpperCamelCase__       ):
			if m_name == ".ATTRIBUTES":
				# variable names end with .ATTRIBUTES/VARIABLE_VALUE
				break
			if m_name.startswith('''layer_with_weights'''       ):
				__UpperCAmelCase							=			int(m_name.split('''-'''       )[-1]       )
				if layer_num <= 2:
					# embedding layers
					# layer_num 0: word_embeddings
					# layer_num 1: position_embeddings
					# layer_num 2: token_type_embeddings
					continue
				elif layer_num == 3:
					# embedding LayerNorm
					trace.extend(['''embeddings''', '''LayerNorm''']       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''embeddings'''       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''LayerNorm'''       )
				elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
					# encoder layers
					trace.extend(['''encoder''', '''layer''', str(layer_num - 4       )]       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''encoder'''       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''layer'''       )
					__UpperCAmelCase							=			pointer[layer_num - 4]
				elif layer_num == config.num_hidden_layers + 4:
					# pooler layer
					trace.extend(['''pooler''', '''dense''']       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''pooler'''       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''dense'''       )
			elif m_name == "embeddings":
				trace.append('''embeddings'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''embeddings'''       )
				if layer_num == 0:
					trace.append('''word_embeddings'''       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''word_embeddings'''       )
				elif layer_num == 1:
					trace.append('''position_embeddings'''       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''position_embeddings'''       )
				elif layer_num == 2:
					trace.append('''token_type_embeddings'''       )
					__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''token_type_embeddings'''       )
				else:
					raise ValueError(f"""Unknown embedding layer with name {full_name}"""       )
				trace.append('''weight'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''weight'''       )
			elif m_name == "_attention_layer":
				# self-attention layer
				trace.extend(['''attention''', '''self''']       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''attention'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''self'''       )
			elif m_name == "_attention_layer_norm":
				# output attention norm
				trace.extend(['''attention''', '''output''', '''LayerNorm''']       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''attention'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''output'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''LayerNorm'''       )
			elif m_name == "_attention_output_dense":
				# output attention dense
				trace.extend(['''attention''', '''output''', '''dense''']       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''attention'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''output'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''dense'''       )
			elif m_name == "_output_dense":
				# output dense
				trace.extend(['''output''', '''dense''']       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''output'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''dense'''       )
			elif m_name == "_output_layer_norm":
				# output dense
				trace.extend(['''output''', '''LayerNorm''']       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''output'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''LayerNorm'''       )
			elif m_name == "_key_dense":
				# attention key
				trace.append('''key'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''key'''       )
			elif m_name == "_query_dense":
				# attention query
				trace.append('''query'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''query'''       )
			elif m_name == "_value_dense":
				# attention value
				trace.append('''value'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''value'''       )
			elif m_name == "_intermediate_dense":
				# attention intermediate dense
				trace.extend(['''intermediate''', '''dense''']       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''intermediate'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''dense'''       )
			elif m_name == "_output_layer_norm":
				# output layer norm
				trace.append('''output'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''output'''       )
			# weights & biases
			elif m_name in ["bias", "beta"]:
				trace.append('''bias'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''bias'''       )
			elif m_name in ["kernel", "gamma"]:
				trace.append('''weight'''       )
				__UpperCAmelCase							=			getattr(UpperCamelCase__    ,					'''weight'''       )
			else:
				logger.warning(f"""Ignored {m_name}"""       )
        # for certain layers reshape is necessary
		__UpperCAmelCase							=			'''.'''.join(UpperCamelCase__       )
		if re.match(R'''(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)'''    ,					UpperCamelCase__       ) or re.match(
		    R'''(\S+)\.attention\.output\.dense\.weight'''    ,					UpperCamelCase__       ):
			__UpperCAmelCase							=			array.reshape(pointer.data.shape       )
		if "kernel" in full_name:
			__UpperCAmelCase							=			array.transpose()
		if pointer.shape == array.shape:
			__UpperCAmelCase							=			torch.from_numpy(UpperCamelCase__       )
		else:
			raise ValueError(
			    f"""Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:"""
			    f""" {array.shape}"""       )
		logger.info(f"""Successfully set variable {full_name} to PyTorch layer {trace}"""       )
	return model





def       lowerCAmelCase					(		UpperCamelCase__				:   Union[str, Any]    ,					UpperCamelCase__				:   Dict    ,					UpperCamelCase__				:   Any       ):


	"""simple docstring"""
	logger.info(f"""Loading model based on config from {config_path}..."""       )
	__UpperCAmelCase							=			BertConfig.from_json_file(UpperCamelCase__       )
	__UpperCAmelCase							=			BertModel(UpperCamelCase__       )

	# Load weights from checkpoint
	logger.info(f"""Loading weights from checkpoint {tf_checkpoint_path}..."""       )
	load_tfa_weights_in_bert(UpperCamelCase__    ,					UpperCamelCase__    ,					UpperCamelCase__       )

	# Save pytorch-model
	logger.info(f"""Saving PyTorch model to {pytorch_dump_path}..."""       )
	torch.save(model.state_dict()    ,					UpperCamelCase__       )


if __name__ == "__main__":
					__lowerCAmelCase	:       Any						       =	argparse.ArgumentParser()
					parser.add_argument(
					    "--tf_checkpoint_path", type=str, required=True, help="Path to the TensorFlow 2.x checkpoint path."
					)
					parser.add_argument(
					    "--bert_config_file",
					    type=str,
					    required=True,
					    help="The config json file corresponding to the BERT model. This specifies the model architecture.",
					)
					parser.add_argument(
					    "--pytorch_dump_path",
					    type=str,
					    required=True,
					    help="Path to the output PyTorch model (must include filename).",
					)
					__lowerCAmelCase	:       List[str]						       =	parser.parse_args()
					convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)

'''simple docstring'''


import argparse
import os
import re

import packaging.version


__lowerCAmelCase	:       Optional[int]						       =	"examples/"
__lowerCAmelCase	:       Dict						       =	{
    "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"),
}
__lowerCAmelCase	:       List[str]						       =	{
    "init": "src/transformers/__init__.py",
    "setup": "setup.py",
}
__lowerCAmelCase	:       int						       =	"README.md"





def       lowerCAmelCase					(		UpperCamelCase__				:   List[str]    ,					UpperCamelCase__				:   int    ,					UpperCamelCase__				:   Tuple       ):


	"""simple docstring"""
	with open(UpperCamelCase__    ,					'''r'''    ,					encoding='''utf-8'''    ,					newline='''\n'''       ) as f:
		__UpperCAmelCase							=			f.read()
	__UpperCAmelCase				,			__UpperCAmelCase							=			REPLACE_PATTERNS[pattern]
	__UpperCAmelCase							=			replace.replace('''VERSION'''    ,					UpperCamelCase__       )
	__UpperCAmelCase							=			re_pattern.sub(UpperCamelCase__    ,					UpperCamelCase__       )
	with open(UpperCamelCase__    ,					'''w'''    ,					encoding='''utf-8'''    ,					newline='''\n'''       ) as f:
		f.write(UpperCamelCase__       )





def       lowerCAmelCase					(		UpperCamelCase__				:   Optional[int]       ):


	"""simple docstring"""
	for folder, directories, fnames in os.walk(UpperCamelCase__       ):
		# 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(UpperCamelCase__    ,					UpperCamelCase__       )    ,					UpperCamelCase__    ,					pattern='''examples'''       )





def       lowerCAmelCase					(		UpperCamelCase__				:   Any    ,					UpperCamelCase__				:   Any=False       ):


	"""simple docstring"""
	for pattern, fname in REPLACE_FILES.items():
		update_version_in_file(UpperCamelCase__    ,					UpperCamelCase__    ,					UpperCamelCase__       )
	if not patch:
		update_version_in_examples(UpperCamelCase__       )





def       lowerCAmelCase					(		):


	"""simple docstring"""
	__UpperCAmelCase							=			'''🤗 Transformers currently provides the following architectures'''
	__UpperCAmelCase							=			'''1. Want to contribute a new model?'''
	with open(UpperCamelCase__    ,					'''r'''    ,					encoding='''utf-8'''    ,					newline='''\n'''       ) as f:
		__UpperCAmelCase							=			f.readlines()

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

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

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





def       lowerCAmelCase					(		):


	"""simple docstring"""
	with open(REPLACE_FILES['''init''']    ,					'''r'''       ) as f:
		__UpperCAmelCase							=			f.read()
	__UpperCAmelCase							=			REPLACE_PATTERNS['''init'''][0].search(UpperCamelCase__       ).groups()[0]
	return packaging.version.parse(UpperCamelCase__       )





def       lowerCAmelCase					(		UpperCamelCase__				:   Any=False       ):


	"""simple docstring"""
	__UpperCAmelCase							=			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:
		__UpperCAmelCase							=			default_version.base_version
	elif patch:
		__UpperCAmelCase							=			f"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}"""
	else:
		__UpperCAmelCase							=			f"""{default_version.major}.{default_version.minor + 1}.0"""

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

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





def       lowerCAmelCase					(		):


	"""simple docstring"""
	__UpperCAmelCase							=			get_version()
	__UpperCAmelCase							=			f"""{current_version.major}.{current_version.minor + 1}.0.dev0"""
	__UpperCAmelCase							=			current_version.base_version

	# Check with the user we got that right.
	__UpperCAmelCase							=			input(f"""Which version are we developing now? [{dev_version}]"""       )
	if len(UpperCamelCase__       ) == 0:
		__UpperCAmelCase							=			dev_version

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


if __name__ == "__main__":
					__lowerCAmelCase	:       Tuple						       =	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.")
					__lowerCAmelCase	:       Tuple						       =	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()
