


from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig


__UpperCAmelCase : List[Any] 			=				{
    'albert-base-v1': 'https://huggingface.co/albert-base-v1/resolve/main/config.json',
    'albert-large-v1': 'https://huggingface.co/albert-large-v1/resolve/main/config.json',
    'albert-xlarge-v1': 'https://huggingface.co/albert-xlarge-v1/resolve/main/config.json',
    'albert-xxlarge-v1': 'https://huggingface.co/albert-xxlarge-v1/resolve/main/config.json',
    'albert-base-v2': 'https://huggingface.co/albert-base-v2/resolve/main/config.json',
    'albert-large-v2': 'https://huggingface.co/albert-large-v2/resolve/main/config.json',
    'albert-xlarge-v2': 'https://huggingface.co/albert-xlarge-v2/resolve/main/config.json',
    'albert-xxlarge-v2': 'https://huggingface.co/albert-xxlarge-v2/resolve/main/config.json',
}



class    UpperCAmelCase_	(							_a):
       '''simple docstring'''
       __UpperCamelCase      :     List[Any]							=					'''albert'''






       def __init__(     self ,					__SCREAMING_SNAKE_CASE=30_000 ,					__SCREAMING_SNAKE_CASE=128 ,					__SCREAMING_SNAKE_CASE=4_096 ,					__SCREAMING_SNAKE_CASE=12 ,					__SCREAMING_SNAKE_CASE=1 ,					__SCREAMING_SNAKE_CASE=64 ,					__SCREAMING_SNAKE_CASE=16_384 ,					__SCREAMING_SNAKE_CASE=1 ,					__SCREAMING_SNAKE_CASE="gelu_new" ,					__SCREAMING_SNAKE_CASE=0 ,					__SCREAMING_SNAKE_CASE=0 ,					__SCREAMING_SNAKE_CASE=512 ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=0.02 ,					__SCREAMING_SNAKE_CASE=1e-12 ,					__SCREAMING_SNAKE_CASE=0.1 ,					__SCREAMING_SNAKE_CASE="absolute" ,					__SCREAMING_SNAKE_CASE=0 ,					__SCREAMING_SNAKE_CASE=2 ,					__SCREAMING_SNAKE_CASE=3 ,					**__SCREAMING_SNAKE_CASE ,					):




              """simple docstring"""




              super().__init__(pad_token_id=A__ ,					bos_token_id=A__ ,					eos_token_id=A__ ,					**A__						)

              UpperCamelCase    :	Tuple   	=		vocab_size
              UpperCamelCase    :	str   	=		embedding_size
              UpperCamelCase    :	List[Any]   	=		hidden_size
              UpperCamelCase    :	Union[str, Any]   	=		num_hidden_layers
              UpperCamelCase    :	Dict   	=		num_hidden_groups
              UpperCamelCase    :	List[str]   	=		num_attention_heads
              UpperCamelCase    :	List[Any]   	=		inner_group_num
              UpperCamelCase    :	Optional[int]   	=		hidden_act
              UpperCamelCase    :	Any   	=		intermediate_size
              UpperCamelCase    :	Tuple   	=		hidden_dropout_prob
              UpperCamelCase    :	Dict   	=		attention_probs_dropout_prob
              UpperCamelCase    :	str   	=		max_position_embeddings
              UpperCamelCase    :	Union[str, Any]   	=		type_vocab_size
              UpperCamelCase    :	str   	=		initializer_range
              UpperCamelCase    :	Tuple   	=		layer_norm_eps
              UpperCamelCase    :	Optional[Any]   	=		classifier_dropout_prob
              UpperCamelCase    :	Any   	=		position_embedding_type




class    UpperCAmelCase_	(							_a):
       '''simple docstring'''






       @property
       def  _lowercase   (     self						):




              """simple docstring"""




              if self.task == "multiple-choice":
                     UpperCamelCase    :	Optional[Any]   	=		{0: """batch""", 1: """choice""", 2: """sequence"""}
              else:
                     UpperCamelCase    :	int   	=		{0: """batch""", 1: """sequence"""}
              return OrderedDict(
                  [
                      ('''input_ids''', dynamic_axis),
                      ('''attention_mask''', dynamic_axis),
                      ('''token_type_ids''', dynamic_axis),
                  ]						)









import json
import os
import shutil
import warnings
from argparse import ArgumentParser, Namespace
from pathlib import Path
from typing import List

from ..utils import logging
from . import BaseTransformersCLICommand


try:
  from cookiecutter.main import cookiecutter

  __UpperCAmelCase : List[Any] 			=				True
except ImportError:
  __UpperCAmelCase : List[str] 			=				False

__UpperCAmelCase : Any 			=				logging.get_logger(__name__)  # pylint: disable=invalid-name


def      a	(							SCREAMING_SNAKE_CASE_      :		Namespace       ):






       """simple docstring"""





       return AddNewModelCommand(args.testing							,			args.testing_file							,			path=args.path       )



class    UpperCAmelCase_	(							_a):
       '''simple docstring'''






       @staticmethod
       def  _lowercase   (     __SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	List[Any]   	=		parser.add_parser('''add-new-model'''						)
              add_new_model_parser.add_argument('''--testing''' ,					action='''store_true''' ,					help='''If in testing mode.'''						)
              add_new_model_parser.add_argument('''--testing_file''' ,					type=__SCREAMING_SNAKE_CASE ,					help='''Configuration file on which to run.'''						)
              add_new_model_parser.add_argument(
                  '''--path''' ,					type=__SCREAMING_SNAKE_CASE ,					help='''Path to cookiecutter. Should only be used for testing purposes.'''						)
              add_new_model_parser.set_defaults(func=__SCREAMING_SNAKE_CASE						)






       def __init__(     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE=None ,					*__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	Tuple   	=		testing
              UpperCamelCase    :	Any   	=		testing_file
              UpperCamelCase    :	Dict   	=		path






       def  _lowercase   (     self						):




              """simple docstring"""




              warnings.warn(
                  '''The command `transformers-cli add-new-model` is deprecated and will be removed in v5 of Transformers. '''
                  '''It is not actively maintained anymore, so might give a result that won\'t pass all tests and quality '''
                  '''checks, you should use `transformers-cli add-new-model-like` instead.'''						)
              if not _has_cookiecutter:
                     raise ImportError(
                         '''Model creation dependencies are required to use the `add_new_model` command. Install them by running '''
                         '''the following at the root of your `transformers` clone:\n\n\t$ pip install -e .[modelcreation]\n'''						)
              # Ensure that there is no other `cookiecutter-template-xxx` directory in the current working directory
              UpperCamelCase    :	List[str]   	=		[directory for directory in os.listdir() if '''cookiecutter-template-''' == directory[:22]]
              if len(__SCREAMING_SNAKE_CASE						) > 0:
                     raise ValueError(
                         '''Several directories starting with `cookiecutter-template-` in current working directory. '''
                         '''Please clean your directory by removing all folders starting with `cookiecutter-template-` or '''
                         '''change your working directory.'''						)

              UpperCamelCase    :	Dict   	=		(
                  Path(__SCREAMING_SNAKE_CASE						).parent.parent.parent.parent if self._path is None else Path(self._path						).parent.parent
              )
              UpperCamelCase    :	List[Any]   	=		path_to_transformer_root / '''templates''' / '''adding_a_new_model'''

              # Execute cookiecutter
              if not self._testing:
                     cookiecutter(str(__SCREAMING_SNAKE_CASE						)						)
              else:
                     with open(self._testing_file ,					'''r'''						) as configuration_file:
                            UpperCamelCase    :	Tuple   	=		json.load(__SCREAMING_SNAKE_CASE						)

                     cookiecutter(
                         str(path_to_cookiecutter if self._path is None else self._path						) ,					no_input=__SCREAMING_SNAKE_CASE ,					extra_context=__SCREAMING_SNAKE_CASE ,					)

              UpperCamelCase    :	Dict   	=		[directory for directory in os.listdir() if '''cookiecutter-template-''' in directory[:22]][0]

              # Retrieve configuration
              with open(directory + '''/configuration.json''' ,					'''r'''						) as configuration_file:
                     UpperCamelCase    :	Tuple   	=		json.load(__SCREAMING_SNAKE_CASE						)

              UpperCamelCase    :	Dict   	=		configuration['''lowercase_modelname''']
              UpperCamelCase    :	int   	=		configuration['''generate_tensorflow_pytorch_and_flax''']
              os.remove(f"""{directory}/configuration.json"""						)

              UpperCamelCase    :	str   	=		'''PyTorch''' in generate_tensorflow_pytorch_and_flax
              UpperCamelCase    :	Any   	=		'''TensorFlow''' in generate_tensorflow_pytorch_and_flax
              UpperCamelCase    :	Union[str, Any]   	=		'''Flax''' in generate_tensorflow_pytorch_and_flax

              UpperCamelCase    :	Optional[Any]   	=		f"""{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}"""
              os.makedirs(__SCREAMING_SNAKE_CASE ,					exist_ok=__SCREAMING_SNAKE_CASE						)
              os.makedirs(f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}""" ,					exist_ok=__SCREAMING_SNAKE_CASE						)

              # Tests require submodules as they have parent imports
              with open(f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/__init__.py""" ,					'''w'''						):
                     pass

              shutil.move(
                  f"""{directory}/__init__.py""" ,					f"""{model_dir}/__init__.py""" ,					)
              shutil.move(
                  f"""{directory}/configuration_{lowercase_model_name}.py""" ,					f"""{model_dir}/configuration_{lowercase_model_name}.py""" ,					)

              def remove_copy_lines(__SCREAMING_SNAKE_CASE						):
                     with open(__SCREAMING_SNAKE_CASE ,					'''r'''						) as f:
                            UpperCamelCase    :	Any   	=		f.readlines()
                     with open(__SCREAMING_SNAKE_CASE ,					'''w'''						) as f:
                            for line in lines:
                                   if "# Copied from transformers." not in line:
                                          f.write(__SCREAMING_SNAKE_CASE						)

              if output_pytorch:
                     if not self._testing:
                            remove_copy_lines(f"""{directory}/modeling_{lowercase_model_name}.py"""						)

                     shutil.move(
                         f"""{directory}/modeling_{lowercase_model_name}.py""" ,					f"""{model_dir}/modeling_{lowercase_model_name}.py""" ,					)

                     shutil.move(
                         f"""{directory}/test_modeling_{lowercase_model_name}.py""" ,					f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_{lowercase_model_name}.py""" ,					)
              else:
                     os.remove(f"""{directory}/modeling_{lowercase_model_name}.py"""						)
                     os.remove(f"""{directory}/test_modeling_{lowercase_model_name}.py"""						)

              if output_tensorflow:
                     if not self._testing:
                            remove_copy_lines(f"""{directory}/modeling_tf_{lowercase_model_name}.py"""						)

                     shutil.move(
                         f"""{directory}/modeling_tf_{lowercase_model_name}.py""" ,					f"""{model_dir}/modeling_tf_{lowercase_model_name}.py""" ,					)

                     shutil.move(
                         f"""{directory}/test_modeling_tf_{lowercase_model_name}.py""" ,					f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_tf_{lowercase_model_name}.py""" ,					)
              else:
                     os.remove(f"""{directory}/modeling_tf_{lowercase_model_name}.py"""						)
                     os.remove(f"""{directory}/test_modeling_tf_{lowercase_model_name}.py"""						)

              if output_flax:
                     if not self._testing:
                            remove_copy_lines(f"""{directory}/modeling_flax_{lowercase_model_name}.py"""						)

                     shutil.move(
                         f"""{directory}/modeling_flax_{lowercase_model_name}.py""" ,					f"""{model_dir}/modeling_flax_{lowercase_model_name}.py""" ,					)

                     shutil.move(
                         f"""{directory}/test_modeling_flax_{lowercase_model_name}.py""" ,					f"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_flax_{lowercase_model_name}.py""" ,					)
              else:
                     os.remove(f"""{directory}/modeling_flax_{lowercase_model_name}.py"""						)
                     os.remove(f"""{directory}/test_modeling_flax_{lowercase_model_name}.py"""						)

              shutil.move(
                  f"""{directory}/{lowercase_model_name}.md""" ,					f"""{path_to_transformer_root}/docs/source/en/model_doc/{lowercase_model_name}.md""" ,					)

              shutil.move(
                  f"""{directory}/tokenization_{lowercase_model_name}.py""" ,					f"""{model_dir}/tokenization_{lowercase_model_name}.py""" ,					)

              shutil.move(
                  f"""{directory}/tokenization_fast_{lowercase_model_name}.py""" ,					f"""{model_dir}/tokenization_{lowercase_model_name}_fast.py""" ,					)

              from os import fdopen, remove
              from shutil import copymode, move
              from tempfile import mkstemp

              def replace(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						):
                     # Create temp file
                     UpperCamelCase	, UpperCamelCase    :	Optional[Any]   	=		mkstemp()
                     UpperCamelCase    :	Tuple   	=		False
                     with fdopen(__SCREAMING_SNAKE_CASE ,					'''w'''						) as new_file:
                            with open(__SCREAMING_SNAKE_CASE						) as old_file:
                                   for line in old_file:
                                          new_file.write(__SCREAMING_SNAKE_CASE						)
                                          if line_to_copy_below in line:
                                                 UpperCamelCase    :	Optional[int]   	=		True
                                                 for line_to_copy in lines_to_copy:
                                                        new_file.write(__SCREAMING_SNAKE_CASE						)

                     if not line_found:
                            raise ValueError(f"""Line {line_to_copy_below} was not found in file."""						)

                     # Copy the file permissions from the old file to the new file
                     copymode(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						)
                     # Remove original file
                     remove(__SCREAMING_SNAKE_CASE						)
                     # Move new file
                     move(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						)

              def skip_units(__SCREAMING_SNAKE_CASE						):
                     return (
                         ("generating PyTorch" in line and not output_pytorch)
                         or ("generating TensorFlow" in line and not output_tensorflow)
                         or ("generating Flax" in line and not output_flax)
                     )

              def replace_in_files(__SCREAMING_SNAKE_CASE						):
                     with open(__SCREAMING_SNAKE_CASE						) as datafile:
                            UpperCamelCase    :	int   	=		[]
                            UpperCamelCase    :	Dict   	=		False
                            UpperCamelCase    :	List[Any]   	=		False
                            for line in datafile:
                                   if "# To replace in: " in line and "##" not in line:
                                          UpperCamelCase    :	Dict   	=		line.split('''"'''						)[1]
                                          UpperCamelCase    :	int   	=		skip_units(__SCREAMING_SNAKE_CASE						)
                                   elif "# Below: " in line and "##" not in line:
                                          UpperCamelCase    :	Dict   	=		line.split('''"'''						)[1]
                                          UpperCamelCase    :	List[str]   	=		skip_units(__SCREAMING_SNAKE_CASE						)
                                   elif "# End." in line and "##" not in line:
                                          if not skip_file and not skip_snippet:
                                                 replace(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						)

                                          UpperCamelCase    :	Dict   	=		[]
                                   elif "# Replace with" in line and "##" not in line:
                                          UpperCamelCase    :	Tuple   	=		[]
                                   elif "##" not in line:
                                          lines_to_copy.append(__SCREAMING_SNAKE_CASE						)

                     remove(__SCREAMING_SNAKE_CASE						)

              replace_in_files(f"""{directory}/to_replace_{lowercase_model_name}.py"""						)
              os.rmdir(__SCREAMING_SNAKE_CASE						)

