from argparse import ArgumentParser

from . import BaseTransformersCLICommand




def    __lowerCAmelCase   (    A_ :			Dict       )     ->	Union[str, Any]:
  return DownloadCommand(args.model    ,						args.cache_dir    ,						args.force    ,						args.trust_remote_code       )





class       UpperCAmelCase__     (		snake_case       ):



  """simple docstring"""






  @staticmethod
  def 						_UpperCAmelCase					(					__lowerCAmelCase:      ArgumentParser )			->			Any:




    '''simple docstring'''




    __UpperCAmelCase         =							parser.add_parser("download" )
    download_parser.add_argument(
        "--cache-dir"					,					type=__SCREAMING_SNAKE_CASE					,					default=__SCREAMING_SNAKE_CASE					,					help="Path to location to store the models" )
    download_parser.add_argument(
        "--force"					,					action="store_true"					,					help="Force the model to be download even if already in cache-dir" )
    download_parser.add_argument(
        "--trust-remote-code"					,					action="store_true"					,					help="Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you've reviewed the code as it will execute on your local machine"					,					)
    download_parser.add_argument("model"					,					type=__SCREAMING_SNAKE_CASE					,					help="Name of the model to download" )
    download_parser.set_defaults(func=__SCREAMING_SNAKE_CASE )






  def __init__(					self:      str					,					__lowerCAmelCase:      str					,					__lowerCAmelCase:      str					,					__lowerCAmelCase:      bool					,					__lowerCAmelCase:      bool )			->			Optional[Any]:




    '''simple docstring'''




    __UpperCAmelCase         =							model
    __UpperCAmelCase         =							cache
    __UpperCAmelCase         =							force
    __UpperCAmelCase         =							trust_remote_code






  def 						_UpperCAmelCase					(					self:      str )			->			List[str]:




    '''simple docstring'''




    from ..models.auto import AutoModel, AutoTokenizer

    AutoModel.from_pretrained(
        self._model					,					cache_dir=self._cache					,					force_download=self._force					,					trust_remote_code=self._trust_remote_code )
    AutoTokenizer.from_pretrained(
        self._model					,					cache_dir=self._cache					,					force_download=self._force					,					trust_remote_code=self._trust_remote_code )






'''simple docstring'''



import inspect
import unittest

from transformers import MobileNetVaConfig
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_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 MobileNetVaForImageClassification, MobileNetVaModel
  from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import MobileNetVaImageProcessor







class 		lowerCAmelCase__  ( a   ):



 """simple docstring"""



 def  UpperCAmelCase__						(						self   :			List[str]     )    ->					str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.config_class(**self.inputs_dict     )
      self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE   ,				"""tf_padding"""     )     )
      self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE   ,				"""depth_multiplier"""     )     )







class 		lowerCAmelCase__  :



 """simple docstring"""



 def __init__(						self   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			str=13   ,				__SCREAMING_SNAKE_CASE   :			int=3   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=32   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]=0.25   ,				__SCREAMING_SNAKE_CASE   :			List[str]=8   ,				__SCREAMING_SNAKE_CASE   :			str=True   ,				__SCREAMING_SNAKE_CASE   :			int=1_024   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]=32   ,				__SCREAMING_SNAKE_CASE   :			List[Any]="relu6"   ,				__SCREAMING_SNAKE_CASE   :			str=0.1   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=0.02   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=True   ,				__SCREAMING_SNAKE_CASE   :			Tuple=True   ,				__SCREAMING_SNAKE_CASE   :			List[Any]=10   ,				__SCREAMING_SNAKE_CASE   :			int=None   ,				)    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = parent
      __SCREAMING_SNAKE_CASE      = batch_size
      __SCREAMING_SNAKE_CASE      = num_channels
      __SCREAMING_SNAKE_CASE      = image_size
      __SCREAMING_SNAKE_CASE      = depth_multiplier
      __SCREAMING_SNAKE_CASE      = min_depth
      __SCREAMING_SNAKE_CASE      = tf_padding
      __SCREAMING_SNAKE_CASE      = int(last_hidden_size * depth_multiplier     )
      __SCREAMING_SNAKE_CASE      = output_stride
      __SCREAMING_SNAKE_CASE      = hidden_act
      __SCREAMING_SNAKE_CASE      = classifier_dropout_prob
      __SCREAMING_SNAKE_CASE      = use_labels
      __SCREAMING_SNAKE_CASE      = is_training
      __SCREAMING_SNAKE_CASE      = num_labels
      __SCREAMING_SNAKE_CASE      = initializer_range
      __SCREAMING_SNAKE_CASE      = scope
 def  UpperCAmelCase__						(						self   :			Optional[int]     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

      __SCREAMING_SNAKE_CASE      = None
      __SCREAMING_SNAKE_CASE      = None
      if self.use_labels:
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size]   ,				self.num_labels     )
           __SCREAMING_SNAKE_CASE      = ids_tensor([self.batch_size, self.image_size, self.image_size]   ,				self.num_labels     )

      __SCREAMING_SNAKE_CASE      = self.get_config()

      return config, pixel_values, labels, pixel_labels
 def  UpperCAmelCase__						(						self   :			Any     )    ->					Tuple:


      """simple docstring"""




      return MobileNetVaConfig(
          num_channels=self.num_channels   ,				image_size=self.image_size   ,				depth_multiplier=self.depth_multiplier   ,				min_depth=self.min_depth   ,				tf_padding=self.tf_padding   ,				hidden_act=self.hidden_act   ,				classifier_dropout_prob=self.classifier_dropout_prob   ,				initializer_range=self.initializer_range   ,				)
 def  UpperCAmelCase__						(						self   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			int   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			int     )    ->					Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = MobileNetVaModel(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE     )
      self.parent.assertEqual(
          result.last_hidden_state.shape   ,				(
              self.batch_size,
              self.last_hidden_size,
              self.image_size // self.output_stride,
              self.image_size // self.output_stride,
          )   ,				)
 def  UpperCAmelCase__						(						self   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Any     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.num_labels
      __SCREAMING_SNAKE_CASE      = MobileNetVaForImageClassification(__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				labels=__SCREAMING_SNAKE_CASE     )
      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.num_labels)     )


 def  UpperCAmelCase__						(						self   :			str     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.prepare_config_and_inputs()
      __SCREAMING_SNAKE_CASE  ,     __SCREAMING_SNAKE_CASE  ,     __SCREAMING_SNAKE_CASE  ,     __SCREAMING_SNAKE_CASE      = config_and_inputs
      __SCREAMING_SNAKE_CASE      = {"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
class 		lowerCAmelCase__  ( a					,   a					,   unittest.TestCase   ):



 """simple docstring"""



 lowerCAmelCase__       = (MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
 lowerCAmelCase__       = (
     {"feature-extraction": MobileNetVaModel, "image-classification": MobileNetVaForImageClassification}
     if is_torch_available()
     else {}
 )

 lowerCAmelCase__       = False
 lowerCAmelCase__       = False
 lowerCAmelCase__       = False
 lowerCAmelCase__       = False
 def  UpperCAmelCase__						(						self   :			str     )    ->					Union[str, Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = MobileNetVaModelTester(self     )
      __SCREAMING_SNAKE_CASE      = MobileNetVaConfigTester(self   ,				config_class=__SCREAMING_SNAKE_CASE   ,				has_text_modality=__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			List[Any]     )    ->					Any:


      """simple docstring"""




      self.config_tester.run_common_tests()
 @unittest.skip(reason="""MobileNetV1 does not use inputs_embeds"""     )
 def  UpperCAmelCase__						(						self   :			str     )    ->					List[Any]:


      """simple docstring"""




      pass
 @unittest.skip(reason="""MobileNetV1 does not support input and output embeddings"""     )
 def  UpperCAmelCase__						(						self   :			Optional[int]     )    ->					List[Any]:


      """simple docstring"""




      pass
 @unittest.skip(reason="""MobileNetV1 does not output attentions"""     )
 def  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Optional[int]:


      """simple docstring"""




      pass
 def  UpperCAmelCase__						(						self   :			int     )    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE  ,     __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs_for_common()

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

           __SCREAMING_SNAKE_CASE      = ["""pixel_values"""]
           self.assertListEqual(arg_names[:1]   ,				__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Tuple     )    ->					str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Any     )    ->					Optional[Any]:


      """simple docstring"""




      def check_hidden_states_output(__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			str     ):
           __SCREAMING_SNAKE_CASE      = model_class(__SCREAMING_SNAKE_CASE     )
           model.to(__SCREAMING_SNAKE_CASE     )
           model.eval()

           with torch.no_grad():
                __SCREAMING_SNAKE_CASE      = model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )     )

           __SCREAMING_SNAKE_CASE      = outputs.hidden_states

           __SCREAMING_SNAKE_CASE      = 26
           self.assertEqual(len(__SCREAMING_SNAKE_CASE     )   ,				__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE  ,     __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           __SCREAMING_SNAKE_CASE      = True
           check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           __SCREAMING_SNAKE_CASE      = True

           check_hidden_states_output(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE     )


 @slow
 def  UpperCAmelCase__						(						self   :			Optional[Any]     )    ->					Optional[Any]:


      """simple docstring"""




      for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __SCREAMING_SNAKE_CASE      = MobileNetVaModel.from_pretrained(__SCREAMING_SNAKE_CASE     )
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE     )







def   a__			(    ):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE      = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
     return image







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



 """simple docstring"""



 @cached_property
 def  UpperCAmelCase__						(						self   :			Dict     )    ->					List[str]:


      """simple docstring"""




      return (
          MobileNetVaImageProcessor.from_pretrained("""google/mobilenet_v1_1.0_224"""     ) if is_vision_available() else None
      )


 @slow
 def  UpperCAmelCase__						(						self   :			Tuple     )    ->					Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = MobileNetVaForImageClassification.from_pretrained("""google/mobilenet_v1_1.0_224"""     ).to(__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = self.default_image_processor
      __SCREAMING_SNAKE_CASE      = prepare_img()
      __SCREAMING_SNAKE_CASE      = image_processor(images=__SCREAMING_SNAKE_CASE   ,				return_tensors="""pt"""     ).to(__SCREAMING_SNAKE_CASE     )

      # forward pass
      with torch.no_grad():
           __SCREAMING_SNAKE_CASE      = model(**__SCREAMING_SNAKE_CASE     )

      # verify the logits
      __SCREAMING_SNAKE_CASE      = torch.Size((1, 1_001)     )
      self.assertEqual(outputs.logits.shape   ,				__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = torch.tensor([-4.1739, -1.1233, 3.1205]     ).to(__SCREAMING_SNAKE_CASE     )

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






