


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

    __lowerCamelCase      :int	    =		True
except ImportError:
    __lowerCamelCase      :Tuple	    =		False

__lowerCamelCase      :Optional[int]	    =		logging.get_logger(__name__)  # pylint: disable=invalid-name




def   snake_case		(     UpperCamelCase__       :						Namespace    )   ->      Optional[int]:
      return AddNewModelCommand(args.testing			,				args.testing_file			,				path=args.path    )






class 			A__	(						__lowercase):


     """simple docstring"""

     @staticmethod
     def 		a__						(	__a:						ArgumentParser	)->    Tuple:
           lowerCamelCase					:					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=__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:						List[Any]     ,		__a:						bool     ,		__a:						str     ,		__a:						Dict=None     ,		*__a:						Optional[Any]	)->    int:
           lowerCamelCase					:					Any        =	testing
           lowerCamelCase					:					Any        =	testing_file
           lowerCamelCase					:					Optional[Any]        =	path







     def 		a__						(	self:						int	)->    Optional[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					:					Optional[Any]        =	[directory for directory in os.listdir() if """cookiecutter-template-""" == directory[:22]]
           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."""	)

           lowerCamelCase					:					List[Any]        =	(
               Path(__a	).parent.parent.parent.parent if self._path is None else Path(self._path	).parent.parent
           )
           lowerCamelCase					:					Optional[int]        =	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:
                       lowerCamelCase					:					Union[str, Any]        =	json.load(__a	)

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

           lowerCamelCase					:					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:
                 lowerCamelCase					:					List[str]        =	json.load(__a	)

           lowerCamelCase					:					Union[str, Any]        =	configuration["""lowercase_modelname"""]
           lowerCamelCase					:					List[str]        =	configuration["""generate_tensorflow_pytorch_and_flax"""]
           os.remove(f'{directory}/configuration.json'	)

           lowerCamelCase					:					Optional[int]        =	"""PyTorch""" in generate_tensorflow_pytorch_and_flax
           lowerCamelCase					:					List[str]        =	"""TensorFlow""" in generate_tensorflow_pytorch_and_flax
           lowerCamelCase					:					Union[str, Any]        =	"""Flax""" in generate_tensorflow_pytorch_and_flax

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

                                   lowerCamelCase					:					str        =	[]
                             elif "# Replace with" in line and "##" not in line:
                                   lowerCamelCase					:					Dict        =	[]
                             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"""


import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
    from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor


class 			A__	:


     """simple docstring"""

     def __init__(	self:						Optional[Any]     ,		__a:						Union[str, Any]     ,		__a:						Optional[Any]=13     ,		__a:						Optional[Any]=32     ,		__a:						Dict=3     ,		__a:						int=4     ,		__a:						Dict=[10, 20, 30, 40]     ,		__a:						int=[2, 2, 3, 2]     ,		__a:						Any=True     ,		__a:						List[Any]=True     ,		__a:						Any=37     ,		__a:						Optional[int]="gelu"     ,		__a:						List[str]=10     ,		__a:						Optional[int]=0.02     ,		__a:						Dict=["stage2", "stage3", "stage4"]     ,		__a:						List[str]=[2, 3, 4]     ,		__a:						List[str]=None     ,		)->    Union[str, Any]:
           lowerCamelCase					:					Optional[int]        =	parent
           lowerCamelCase					:					Optional[int]        =	batch_size
           lowerCamelCase					:					Any        =	image_size
           lowerCamelCase					:					Tuple        =	num_channels
           lowerCamelCase					:					str        =	num_stages
           lowerCamelCase					:					List[str]        =	hidden_sizes
           lowerCamelCase					:					str        =	depths
           lowerCamelCase					:					Dict        =	is_training
           lowerCamelCase					:					Optional[Any]        =	use_labels
           lowerCamelCase					:					List[str]        =	intermediate_size
           lowerCamelCase					:					List[str]        =	hidden_act
           lowerCamelCase					:					List[str]        =	num_labels
           lowerCamelCase					:					Union[str, Any]        =	initializer_range
           lowerCamelCase					:					List[Any]        =	out_features
           lowerCamelCase					:					Optional[Any]        =	out_indices
           lowerCamelCase					:					int        =	scope

     def 		a__						(	self:						str	)->    Optional[Any]:
           lowerCamelCase					:					Union[str, Any]        =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

           lowerCamelCase					:					Dict        =	None
           if self.use_labels:
                 lowerCamelCase					:					Dict        =	ids_tensor([self.batch_size]     ,		self.num_labels	)

           lowerCamelCase					:					Any        =	self.get_config()
           return config, pixel_values, labels

     def 		a__						(	self:						Dict	)->    Union[str, Any]:
           return ConvNextConfig(
               num_channels=self.num_channels     ,		hidden_sizes=self.hidden_sizes     ,		depths=self.depths     ,		num_stages=self.num_stages     ,		hidden_act=self.hidden_act     ,		is_decoder=__a     ,		initializer_range=self.initializer_range     ,		out_features=self.out_features     ,		out_indices=self.out_indices     ,		num_labels=self.num_labels     ,		)

     def 		a__						(	self:						Optional[Any]     ,		__a:						List[Any]     ,		__a:						Any     ,		__a:						int	)->    List[Any]:
           lowerCamelCase					:					Optional[int]        =	ConvNextModel(config=__a	)
           model.to(__a	)
           model.eval()
           lowerCamelCase					:					Any        =	model(__a	)
           # expected last hidden states: B, C, H // 32, W // 32
           self.parent.assertEqual(
               result.last_hidden_state.shape     ,		(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)     ,		)

     def 		a__						(	self:						int     ,		__a:						Union[str, Any]     ,		__a:						List[Any]     ,		__a:						Tuple	)->    Optional[int]:
           lowerCamelCase					:					str        =	ConvNextForImageClassification(__a	)
           model.to(__a	)
           model.eval()
           lowerCamelCase					:					Any        =	model(__a     ,		labels=__a	)
           self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_labels)	)

     def 		a__						(	self:						List[Any]     ,		__a:						Any     ,		__a:						Optional[int]     ,		__a:						Tuple	)->    List[str]:
           lowerCamelCase					:					List[str]        =	ConvNextBackbone(config=__a	)
           model.to(__a	)
           model.eval()
           lowerCamelCase					:					int        =	model(__a	)

           # verify hidden states
           self.parent.assertEqual(len(result.feature_maps	)     ,		len(config.out_features	)	)
           self.parent.assertListEqual(list(result.feature_maps[0].shape	)     ,		[self.batch_size, self.hidden_sizes[1], 4, 4]	)

           # verify channels
           self.parent.assertEqual(len(model.channels	)     ,		len(config.out_features	)	)
           self.parent.assertListEqual(model.channels     ,		config.hidden_sizes[1:]	)

           # verify backbone works with out_features=None
           lowerCamelCase					:					Tuple        =	None
           lowerCamelCase					:					List[str]        =	ConvNextBackbone(config=__a	)
           model.to(__a	)
           model.eval()
           lowerCamelCase					:					List[Any]        =	model(__a	)

           # verify feature maps
           self.parent.assertEqual(len(result.feature_maps	)     ,		1	)
           self.parent.assertListEqual(list(result.feature_maps[0].shape	)     ,		[self.batch_size, self.hidden_sizes[-1], 1, 1]	)

           # verify channels
           self.parent.assertEqual(len(model.channels	)     ,		1	)
           self.parent.assertListEqual(model.channels     ,		[config.hidden_sizes[-1]]	)







     def 		a__						(	self:						Optional[Any]	)->    Any:
           lowerCamelCase					:					List[Any]        =	self.prepare_config_and_inputs()
           lowerCamelCase     ,			lowerCamelCase     ,			lowerCamelCase					:					Tuple        =	config_and_inputs
           lowerCamelCase					:					int        =	{"""pixel_values""": pixel_values}
           return config, inputs_dict


@require_torch
class 			A__	(						__lowercase ,     __lowercase ,     unittest.TestCase):


     """simple docstring"""
     snake_case__	:					int													=(
         (
             ConvNextModel,
             ConvNextForImageClassification,
             ConvNextBackbone,
         )
         if is_torch_available()
         else ()
     )
     snake_case__	:					str													=(
         {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
         if is_torch_available()
         else {}
     )

     snake_case__	:					Union[str, Any]													=True
     snake_case__	:					Optional[int]													=False
     snake_case__	:					Tuple													=False
     snake_case__	:					Union[str, Any]													=False
     snake_case__	:					Tuple													=False

     def 		a__						(	self:						Optional[Any]	)->    Union[str, Any]:
           lowerCamelCase					:					Tuple        =	ConvNextModelTester(self	)
           lowerCamelCase					:					List[Any]        =	ConfigTester(self     ,		config_class=__a     ,		has_text_modality=__a     ,		hidden_size=37	)

     def 		a__						(	self:						Optional[int]	)->    Dict:
           self.create_and_test_config_common_properties()
           self.config_tester.create_and_test_config_to_json_string()
           self.config_tester.create_and_test_config_to_json_file()
           self.config_tester.create_and_test_config_from_and_save_pretrained()
           self.config_tester.create_and_test_config_with_num_labels()
           self.config_tester.check_config_can_be_init_without_params()
           self.config_tester.check_config_arguments_init()

     def 		a__						(	self:						Optional[int]	)->    Optional[Any]:
           return

     @unittest.skip(reason="""ConvNext does not use inputs_embeds"""	)
     def 		a__						(	self:						int	)->    Dict:
           pass

     @unittest.skip(reason="""ConvNext does not support input and output embeddings"""	)
     def 		a__						(	self:						Dict	)->    Optional[Any]:
           pass

     @unittest.skip(reason="""ConvNext does not use feedforward chunking"""	)
     def 		a__						(	self:						int	)->    List[Any]:
           pass

     def 		a__						(	self:						Union[str, Any]	)->    int:
           lowerCamelCase     ,			lowerCamelCase					:					List[str]        =	self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 lowerCamelCase					:					Any        =	model_class(__a	)
                 lowerCamelCase					:					str        =	inspect.signature(model.forward	)
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 lowerCamelCase					:					Optional[Any]        =	[*signature.parameters.keys()]

                 lowerCamelCase					:					List[str]        =	["""pixel_values"""]
                 self.assertListEqual(arg_names[:1]     ,		__a	)

     def 		a__						(	self:						Optional[int]	)->    str:
           lowerCamelCase					:					Any        =	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*__a	)

     def 		a__						(	self:						str	)->    int:
           lowerCamelCase					:					int        =	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*__a	)

     def 		a__						(	self:						int	)->    Optional[int]:
           def check_hidden_states_output(__a:						Tuple     ,		__a:						int     ,		__a:						Tuple	):
                 lowerCamelCase					:					str        =	model_class(__a	)
                 model.to(__a	)
                 model.eval()

                 with torch.no_grad():
                       lowerCamelCase					:					Tuple        =	model(**self._prepare_for_class(__a     ,		__a	)	)

                 lowerCamelCase					:					int        =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                 lowerCamelCase					:					Optional[int]        =	self.model_tester.num_stages
                 self.assertEqual(len(__a	)     ,		expected_num_stages + 1	)

                 # ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
                 self.assertListEqual(
                     list(hidden_states[0].shape[-2:]	)     ,		[self.model_tester.image_size // 4, self.model_tester.image_size // 4]     ,		)

           lowerCamelCase     ,			lowerCamelCase					:					List[Any]        =	self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 lowerCamelCase					:					List[Any]        =	True
                 check_hidden_states_output(__a     ,		__a     ,		__a	)

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 lowerCamelCase					:					Tuple        =	True

                 check_hidden_states_output(__a     ,		__a     ,		__a	)

     def 		a__						(	self:						Dict	)->    Optional[Any]:
           lowerCamelCase					:					List[str]        =	self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*__a	)







     @slow
     def 		a__						(	self:						Optional[Any]	)->    Tuple:
           for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 lowerCamelCase					:					str        =	ConvNextModel.from_pretrained(__a	)
                 self.assertIsNotNone(__a	)




def   snake_case		(     )   ->      Optional[int]:
      lowerCamelCase					:					int        =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      return image


@require_torch
@require_vision
class 			A__	(						unittest.TestCase):


     """simple docstring"""

     @cached_property
     def 		a__						(	self:						Dict	)->    Union[str, Any]:
           return AutoImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""	) if is_vision_available() else None







     @slow
     def 		a__						(	self:						List[str]	)->    Dict:
           lowerCamelCase					:					Tuple        =	ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""	).to(__a	)

           lowerCamelCase					:					Dict        =	self.default_image_processor
           lowerCamelCase					:					Union[str, Any]        =	prepare_img()
           lowerCamelCase					:					Optional[Any]        =	image_processor(images=__a     ,		return_tensors="""pt"""	).to(__a	)

           # forward pass
           with torch.no_grad():
                 lowerCamelCase					:					Any        =	model(**__a	)

           # verify the logits
           lowerCamelCase					:					Union[str, Any]        =	torch.Size((1, 1_000)	)
           self.assertEqual(outputs.logits.shape     ,		__a	)

           lowerCamelCase					:					Tuple        =	torch.tensor([-0.02_60, -0.47_39, 0.19_11]	).to(__a	)

           self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,		__a     ,		atol=1e-4	)	)


@require_torch
class 			A__	(						unittest.TestCase ,     __lowercase):


     """simple docstring"""
     snake_case__	:					Union[str, Any]													=(ConvNextBackbone,) if is_torch_available() else ()
     snake_case__	:					Optional[Any]													=ConvNextConfig

     snake_case__	:					Optional[Any]													=False

     def 		a__						(	self:						List[str]	)->    int:
           lowerCamelCase					:					Dict        =	ConvNextModelTester(self	)




