






'''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    	=   True
except ImportError:
      __A    	=   False

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




def        _SCREAMING_SNAKE_CASE  (				A  :       Namespace  )    -> str:







   """simple docstring"""
   return AddNewModelCommand(args.testing  ,		args.testing_file  ,		path=args.path  )





class a_    (    UpperCamelCase_							):







   @staticmethod
   def     SCREAMING_SNAKE_CASE__					(__a)			->      Union[str, Any]:
      __snake_case				:      Optional[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=__a					,   help='Configuration file on which to run.')
      add_new_model_parser.add_argument(
          '--path'					,   type=__a					,   help='Path to cookiecutter. Should only be used for testing purposes.')
      add_new_model_parser.set_defaults(func=__a)







   def __init__(self					,   __a					,   __a					,   __a=None					,   *__a)			->      int:
      __snake_case				:      Optional[int]     							= testing
      __snake_case				:      List[str]     							= testing_file
      __snake_case				:      Optional[Any]     							= path







   def     SCREAMING_SNAKE_CASE__					(self)			->      Any:
      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
      __snake_case				:      Any     							= [directory for directory in os.listdir() if 'cookiecutter-template-' == directory[:2_2]]
      if len(__a) > 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.')

      __snake_case				:      Union[str, Any]     							= (
          Path(__a).parent.parent.parent.parent if self._path is None else Path(self._path).parent.parent
      )
      __snake_case				:      str     							= path_to_transformer_root / 'templates' / 'adding_a_new_model'

      # Execute cookiecutter
      if not self._testing:
         cookiecutter(str(__a))
      else:
         with open(self._testing_file					,   'r') as configuration_file:
            __snake_case				:      List[Any]     							= json.load(__a)

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

      __snake_case				:      Union[str, Any]     							= [directory for directory in os.listdir() if 'cookiecutter-template-' in directory[:2_2]][0]

      # Retrieve configuration
      with open(directory + '/configuration.json'					,   'r') as configuration_file:
         __snake_case				:      List[str]     							= json.load(__a)

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

      __snake_case				:      str     							= 'PyTorch' in generate_tensorflow_pytorch_and_flax
      __snake_case				:      str     							= 'TensorFlow' in generate_tensorflow_pytorch_and_flax
      __snake_case				:      Any     							= 'Flax' in generate_tensorflow_pytorch_and_flax

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

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

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

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

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

                  __snake_case				:      List[Any]     							= []
               elif "# Replace with" in line and "##" not in line:
                  __snake_case				:      List[str]     							= []
               elif "##" not in line:
                  lines_to_copy.append(__a)

         remove(__a)

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







'''simple docstring'''






from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
      import PIL


__A    	=   logging.get_logger(__name__)




class a_    (    UpperCamelCase_							):
   _snake_case        =							["""pixel_values"""]







   def __init__(self					,   __a = True					,   __a = None					,   __a = None					,   __a = PILImageResampling.BILINEAR					,   __a = True					,   __a = 1 / 2_5_5					,   __a = True					,   __a = None					,   __a = None					,   **__a					,   )			->      None:
      """simple docstring"""






      super().__init__(**__a)
      __snake_case				:      Tuple     							= size if size is not None else {'shortest_edge': 3_8_4}
      __snake_case				:      List[Any]     							= get_size_dict(__a					,   default_to_square=__a)

      __snake_case				:      int     							= do_resize
      __snake_case				:      List[str]     							= size
      # Default value set here for backwards compatibility where the value in config is None
      __snake_case				:      Any     							= crop_pct if crop_pct is not None else 2_2_4 / 2_5_6
      __snake_case				:      Tuple     							= resample
      __snake_case				:      Dict     							= do_rescale
      __snake_case				:      Any     							= rescale_factor
      __snake_case				:      str     							= do_normalize
      __snake_case				:      Union[str, Any]     							= image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
      __snake_case				:      Dict     							= image_std if image_std is not None else IMAGENET_STANDARD_STD







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a					,   __a = PILImageResampling.BICUBIC					,   __a = None					,   **__a					,   )			->      np.ndarray:
      """simple docstring"""






      __snake_case				:      Dict     							= get_size_dict(__a					,   default_to_square=__a)
      if "shortest_edge" not in size:
         raise ValueError(F"""Size dictionary must contain 'shortest_edge' key. Got {size.keys()}""")
      __snake_case				:      List[str]     							= size['shortest_edge']

      if shortest_edge < 3_8_4:
         # maintain same ratio, resizing shortest edge to shortest_edge/crop_pct
         __snake_case				:      Any     							= int(shortest_edge / crop_pct)
         __snake_case				:      Any     							= get_resize_output_image_size(__a					,   size=__a					,   default_to_square=__a)
         __snake_case				:      int     							= resize(image=__a					,   size=__a					,   resample=__a					,   data_format=__a					,   **__a)
         # then crop to (shortest_edge, shortest_edge)
         return center_crop(image=__a					,   size=(shortest_edge, shortest_edge)					,   data_format=__a					,   **__a)
      else:
         # warping (no cropping) when evaluated at 384 or larger
         return resize(
             __a					,   size=(shortest_edge, shortest_edge)					,   resample=__a					,   data_format=__a					,   **__a)







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a = None					,   **__a					,   )			->      Any:
      """simple docstring"""






      return rescale(__a					,   scale=__a					,   data_format=__a					,   **__a)







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a					,   __a					,   __a = None					,   **__a					,   )			->      np.ndarray:
      """simple docstring"""






      return normalize(__a					,   mean=__a					,   std=__a					,   data_format=__a					,   **__a)







   def     SCREAMING_SNAKE_CASE__					(self					,   __a					,   __a = None					,   __a = None					,   __a = None					,   __a = None					,   __a = None					,   __a = None					,   __a = None					,   __a = None					,   __a = None					,   __a = None					,   __a = ChannelDimension.FIRST					,   **__a					,   )			->      PIL.Image.Image:
      """simple docstring"""






      __snake_case				:      Optional[int]     							= do_resize if do_resize is not None else self.do_resize
      __snake_case				:      Dict     							= crop_pct if crop_pct is not None else self.crop_pct
      __snake_case				:      Tuple     							= resample if resample is not None else self.resample
      __snake_case				:      Any     							= do_rescale if do_rescale is not None else self.do_rescale
      __snake_case				:      Any     							= rescale_factor if rescale_factor is not None else self.rescale_factor
      __snake_case				:      Union[str, Any]     							= do_normalize if do_normalize is not None else self.do_normalize
      __snake_case				:      Optional[int]     							= image_mean if image_mean is not None else self.image_mean
      __snake_case				:      Optional[Any]     							= image_std if image_std is not None else self.image_std

      __snake_case				:      List[str]     							= size if size is not None else self.size
      __snake_case				:      Any     							= get_size_dict(__a					,   default_to_square=__a)

      __snake_case				:      Dict     							= make_list_of_images(__a)

      if not valid_images(__a):
         raise ValueError(
             'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
             'torch.Tensor, tf.Tensor or jax.ndarray.')

      if do_resize and size is None or resample is None:
         raise ValueError('Size and resample must be specified if do_resize is True.')

      if do_resize and size["shortest_edge"] < 3_8_4 and crop_pct is None:
         raise ValueError('crop_pct must be specified if size < 384.')

      if do_rescale and rescale_factor is None:
         raise ValueError('Rescale factor must be specified if do_rescale is True.')

      if do_normalize and (image_mean is None or image_std is None):
         raise ValueError('Image mean and std must be specified if do_normalize is True.')

      # All transformations expect numpy arrays.
      __snake_case				:      Tuple     							= [to_numpy_array(__a) for image in images]

      if do_resize:
         __snake_case				:      Optional[int]     							= [self.resize(image=__a					,   size=__a					,   crop_pct=__a					,   resample=__a) for image in images]

      if do_rescale:
         __snake_case				:      Optional[int]     							= [self.rescale(image=__a					,   scale=__a) for image in images]

      if do_normalize:
         __snake_case				:      Any     							= [self.normalize(image=__a					,   mean=__a					,   std=__a) for image in images]

      __snake_case				:      Dict     							= [to_channel_dimension_format(__a					,   __a) for image in images]

      __snake_case				:      Union[str, Any]     							= {'pixel_values': images}
      return BatchFeature(data=__a					,   tensor_type=__a)