


'''simple docstring'''






from string import ascii_uppercase

__A					:  Tuple											=      {str(ord(c) - 55): c for c in ascii_uppercase}







def 				UpperCamelCase_			(    A__					:   int							,    A__					:   int					):
  '''simple docstring'''





  if isinstance(A__							,    A__					):
    raise TypeError("""int() can't convert non-string with explicit base"""					)
  if num < 0:
    raise ValueError("""parameter must be positive int"""					)
  if isinstance(A__							,    A__					):
    raise TypeError("""'str' object cannot be interpreted as an integer"""					)
  if isinstance(A__							,    A__					):
    raise TypeError("""'float' object cannot be interpreted as an integer"""					)
  if base in (0, 1):
    raise ValueError("""base must be >= 2"""					)
  if base > 36:
    raise ValueError("""base must be <= 36"""					)
  lowerCAmelCase_			:      Any			=   """"""
  lowerCAmelCase_			:      Optional[int]			=   0
  lowerCAmelCase_			:      List[str]			=   0
  while div != 1:
    lowerCAmelCase_,							lowerCAmelCase_			:      Any			=   divmod(A__							,    A__					)
    if base >= 11 and 9 < mod < 36:
      lowerCAmelCase_			:      Dict			=   ALPHABET_VALUES[str(A__					)]
    else:
      lowerCAmelCase_			:      List[str]			=   str(A__					)
    new_value += actual_value
    lowerCAmelCase_			:      Union[str, Any]			=   num // base
    lowerCAmelCase_			:      int			=   div
    if div == 0:
      return str(new_value[::-1]					)
    elif div == 1:
      new_value += str(A__					)
      return str(new_value[::-1]					)

  return new_value[::-1]


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  for base in range(2, 37):
    for num in range(1000):
      assert int(decimal_to_any(num, base), base) == num, (
          num,
          base,
          decimal_to_any(num, base),
          int(decimal_to_any(num, base), base),
      )







'''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

  __A					:  List[Any]											=      True
except ImportError:
  __A					:  int											=      False

__A					:  str											=      logging.get_logger(__name__)  # pylint: disable=invalid-name







def 				UpperCamelCase_			(    A__					:   Namespace					):
  '''simple docstring'''





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






class    __snake_case       (   _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    @staticmethod
    def __lowercase   (   lowerCamelCase    :  ArgumentParser		)   ->  int:
      lowerCAmelCase_			:      Optional[int]			=   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=lowerCamelCase    ,						help="""Configuration file on which to run."""		)
      add_new_model_parser.add_argument(
          """--path"""    ,						type=lowerCamelCase    ,						help="""Path to cookiecutter. Should only be used for testing purposes."""		)
      add_new_model_parser.set_defaults(func=lowerCamelCase		)

    def __init__(   self    :  List[str]    ,						lowerCamelCase    :  bool    ,						lowerCamelCase    :  str    ,						lowerCamelCase    :  Any=None    ,						*lowerCamelCase    :  List[str]		)   ->  Optional[Any]:
      lowerCAmelCase_			:      int			=   testing
      lowerCAmelCase_			:      Union[str, Any]			=   testing_file
      lowerCAmelCase_			:      Tuple			=   path





    def __lowercase   (   self    :  Tuple		)   ->  int:
      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
      lowerCAmelCase_			:      int			=   [directory for directory in os.listdir() if """cookiecutter-template-""" == directory[:22]]
      if len(lowerCamelCase		) > 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."""		)

      lowerCAmelCase_			:      List[Any]			=   (
          Path(lowerCamelCase		).parent.parent.parent.parent if self._path is None else Path(self._path		).parent.parent
      )
      lowerCAmelCase_			:      Dict			=   path_to_transformer_root / """templates""" / """adding_a_new_model"""

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

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

      lowerCAmelCase_			:      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:
        lowerCAmelCase_			:      Tuple			=   json.load(lowerCamelCase		)

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

      lowerCAmelCase_			:      Dict			=   """PyTorch""" in generate_tensorflow_pytorch_and_flax
      lowerCAmelCase_			:      Optional[int]			=   """TensorFlow""" in generate_tensorflow_pytorch_and_flax
      lowerCAmelCase_			:      List[str]			=   """Flax""" in generate_tensorflow_pytorch_and_flax

      lowerCAmelCase_			:      Union[str, Any]			=   F'{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}'
      os.makedirs(lowerCamelCase    ,						exist_ok=lowerCamelCase		)
      os.makedirs(F'{path_to_transformer_root}/tests/models/{lowercase_model_name}'    ,						exist_ok=lowerCamelCase		)

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

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

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

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

              lowerCAmelCase_			:      Dict			=   []
            elif "# Replace with" in line and "##" not in line:
              lowerCAmelCase_			:      int			=   []
            elif "##" not in line:
              lines_to_copy.append(lowerCamelCase		)

        remove(lowerCamelCase		)

      replace_in_files(F'{directory}/to_replace_{lowercase_model_name}.py'		)
      os.rmdir(lowerCamelCase		)



