


'''simple docstring'''
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_			:  Optional[int]										=   True
except ImportError:
 UpperCAmelCase_			:  List[Any]										=   False

UpperCAmelCase_			:  Tuple										=   logging.get_logger(__name__)  # pylint: disable=invalid-name


def       _lowercase							(					UpperCamelCase__							:       Namespace      ):
 return AddNewModelCommand(args.testing,					args.testing_file,					path=args.path      )


class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''


 @staticmethod
 def 			snake_case__ (   __lowercase    ):

  """simple docstring"""







  __A	:		Dict	  =      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=__lowercase   ,   help='Configuration file on which to run.'    )
  add_new_model_parser.add_argument(
      '--path'   ,   type=__lowercase   ,   help='Path to cookiecutter. Should only be used for testing purposes.'    )
  add_new_model_parser.set_defaults(func=__lowercase    )


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

  """simple docstring"""







  __A	:		Dict	  =      testing
  __A	:		Any	  =      testing_file
  __A	:		Optional[Any]	  =      path







 def 			snake_case__ (   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
  __A	:		Any	  =      [directory for directory in os.listdir() if 'cookiecutter-template-' == directory[:22]]
  if len(__lowercase    ) > 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.'    )

  __A	:		Dict	  =      (
      Path(__lowercase    ).parent.parent.parent.parent if self._path is None else Path(self._path    ).parent.parent
  )
  __A	:		Optional[int]	  =      path_to_transformer_root / 'templates' / 'adding_a_new_model'

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

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

  __A	:		List[str]	  =      [directory for directory in os.listdir() if 'cookiecutter-template-' in directory[:22]][0]

  # Retrieve configuration
  with open(directory + '/configuration.json'   ,   'r'    ) as configuration_file:
   __A	:		int	  =      json.load(__lowercase    )

  __A	:		Tuple	  =      configuration['lowercase_modelname']
  __A	:		str	  =      configuration['generate_tensorflow_pytorch_and_flax']
  os.remove(F"""{directory}/configuration.json"""    )

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

  __A	:		Optional[Any]	  =      F"""{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}"""
  os.makedirs(__lowercase   ,   exist_ok=__lowercase    )
  os.makedirs(F"""{path_to_transformer_root}/tests/models/{lowercase_model_name}"""   ,   exist_ok=__lowercase    )

  # 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(__lowercase    ):
   with open(__lowercase   ,   'r'    ) as f:
    __A	:		List[Any]	  =      f.readlines()
   with open(__lowercase   ,   'w'    ) as f:
    for line in lines:
     if "# Copied from transformers." not in line:
      f.write(__lowercase    )

  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(__lowercase   ,   __lowercase   ,   __lowercase    ):
   # Create temp file
   __A  ,__A	:		Tuple	  =      mkstemp()
   __A	:		int	  =      False
   with fdopen(__lowercase   ,   'w'    ) as new_file:
    with open(__lowercase    ) as old_file:
     for line in old_file:
      new_file.write(__lowercase    )
      if line_to_copy_below in line:
       __A	:		Optional[Any]	  =      True
       for line_to_copy in lines_to_copy:
        new_file.write(__lowercase    )

   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(__lowercase   ,   __lowercase    )
   # Remove original file
   remove(__lowercase    )
   # Move new file
   move(__lowercase   ,   __lowercase    )

  def skip_units(__lowercase    ):
   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(__lowercase    ):
   with open(__lowercase    ) as datafile:
    __A	:		Tuple	  =      []
    __A	:		Optional[Any]	  =      False
    __A	:		Dict	  =      False
    for line in datafile:
     if "# To replace in: " in line and "##" not in line:
      __A	:		List[str]	  =      line.split('"'    )[1]
      __A	:		Optional[int]	  =      skip_units(__lowercase    )
     elif "# Below: " in line and "##" not in line:
      __A	:		List[Any]	  =      line.split('"'    )[1]
      __A	:		Optional[int]	  =      skip_units(__lowercase    )
     elif "# End." in line and "##" not in line:
      if not skip_file and not skip_snippet:
       replace(__lowercase   ,   __lowercase   ,   __lowercase    )

      __A	:		Tuple	  =      []
     elif "# Replace with" in line and "##" not in line:
      __A	:		Optional[Any]	  =      []
     elif "##" not in line:
      lines_to_copy.append(__lowercase    )

   remove(__lowercase    )

  replace_in_files(F"""{directory}/to_replace_{lowercase_model_name}.py"""    )
  os.rmdir(__lowercase    )










'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase_			:  Dict										=   {
    'configuration_distilbert': [
        'DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'DistilBertConfig',
        'DistilBertOnnxConfig',
    ],
    'tokenization_distilbert': ['DistilBertTokenizer'],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  List[Any]										=   ['DistilBertTokenizerFast']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  int										=   [
     'DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'DistilBertForMaskedLM',
     'DistilBertForMultipleChoice',
     'DistilBertForQuestionAnswering',
     'DistilBertForSequenceClassification',
     'DistilBertForTokenClassification',
     'DistilBertModel',
     'DistilBertPreTrainedModel',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  Optional[int]										=   [
     'TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFDistilBertForMaskedLM',
     'TFDistilBertForMultipleChoice',
     'TFDistilBertForQuestionAnswering',
     'TFDistilBertForSequenceClassification',
     'TFDistilBertForTokenClassification',
     'TFDistilBertMainLayer',
     'TFDistilBertModel',
     'TFDistilBertPreTrainedModel',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase_			:  List[str]										=   [
     'FlaxDistilBertForMaskedLM',
     'FlaxDistilBertForMultipleChoice',
     'FlaxDistilBertForQuestionAnswering',
     'FlaxDistilBertForSequenceClassification',
     'FlaxDistilBertForTokenClassification',
     'FlaxDistilBertModel',
     'FlaxDistilBertPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_distilbert import (
     DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
     DistilBertConfig,
     DistilBertOnnxConfig,
 )
 from .tokenization_distilbert import DistilBertTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_distilbert_fast import DistilBertTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_distilbert import (
      DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      DistilBertForMaskedLM,
      DistilBertForMultipleChoice,
      DistilBertForQuestionAnswering,
      DistilBertForSequenceClassification,
      DistilBertForTokenClassification,
      DistilBertModel,
      DistilBertPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_distilbert import (
      TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFDistilBertForMaskedLM,
      TFDistilBertForMultipleChoice,
      TFDistilBertForQuestionAnswering,
      TFDistilBertForSequenceClassification,
      TFDistilBertForTokenClassification,
      TFDistilBertMainLayer,
      TFDistilBertModel,
      TFDistilBertPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_distilbert import (
      FlaxDistilBertForMaskedLM,
      FlaxDistilBertForMultipleChoice,
      FlaxDistilBertForQuestionAnswering,
      FlaxDistilBertForSequenceClassification,
      FlaxDistilBertForTokenClassification,
      FlaxDistilBertModel,
      FlaxDistilBertPreTrainedModel,
  )

else:
 import sys

 UpperCAmelCase_			:  Optional[Any]										=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






