
'''simple docstring'''







import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
  import torch

  from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin







class UpperCAmelCase__	:





  """simple docstring"""

  def __init__(		self      :     int							,_a      :     Optional[Any]							,_a      :     Optional[int]=None							,_a      :     Optional[Any]=None							,_a      :     List[Any]=None							,_a      :     int="resnet50"							,_a      :     Any=3							,_a      :     Tuple=32							,_a      :     Optional[Any]=3							,_a      :     str=True							,_a      :     Dict=True							,):


     '''simple docstring'''






     _a				:	List[Any]			=   parent
     _a				:	str			=   out_indices if out_indices is not None else [4]
     _a				:	Dict			=   stage_names
     _a				:	str			=   out_features
     _a				:	Tuple			=   backbone
     _a				:	Optional[int]			=   batch_size
     _a				:	Optional[Any]			=   image_size
     _a				:	Optional[Any]			=   num_channels
     _a				:	Dict			=   use_pretrained_backbone
     _a				:	List[str]			=   is_training


  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     _a				:	Optional[int]			=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )
     _a				:	List[str]			=   self.get_config()

     return config, pixel_values


  def   __lowercase		(		self      :     Optional[int]       ):


     '''simple docstring'''






     return TimmBackboneConfig(
         image_size=self.image_size							,num_channels=self.num_channels							,out_features=self.out_features							,out_indices=self.out_indices							,stage_names=self.stage_names							,use_pretrained_backbone=self.use_pretrained_backbone							,backbone=self.backbone							,)


  def   __lowercase		(		self      :     Union[str, Any]							,_a      :     str							,_a      :     List[Any]       ):


     '''simple docstring'''






     _a				:	Optional[int]			=   TimmBackbone(config=_a       )
     model.to(_a       )
     model.eval()
     with torch.no_grad():
        _a				:	List[Any]			=   model(_a       )
     self.parent.assertEqual(
         result.feature_map[-1].shape							,(self.batch_size, model.channels[-1], 14, 14)							,)


  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     _a				:	Optional[int]			=   self.prepare_config_and_inputs()
     _a				:	str			=   config_and_inputs
     _a				:	List[Any]			=   {"pixel_values": pixel_values}
     return config, inputs_dict







@require_torch
@require_timm
class UpperCAmelCase__	( a_    ,				a_    ,				a_    ,				unittest.TestCase	):





  """simple docstring"""

  __UpperCAmelCase				:				str   =					(TimmBackbone,) if is_torch_available() else ()
  __UpperCAmelCase				:				List[str]   =					{'''feature-extraction''': TimmBackbone} if is_torch_available() else {}
  __UpperCAmelCase				:				Optional[int]   =					False
  __UpperCAmelCase				:				str   =					False
  __UpperCAmelCase				:				int   =					False
  __UpperCAmelCase				:				str   =					False


  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     _a				:	Optional[Any]			=   TimmBackboneModelTester(self       )
     _a				:	str			=   ConfigTester(self							,config_class=_a							,has_text_modality=_a       )


  def   __lowercase		(		self      :     str       ):


     '''simple docstring'''






     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   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     _a				:	Union[str, Any]			=   "resnet18"
     _a				:	List[Any]			=   "microsoft/resnet-18"

     _a				:	Optional[int]			=   AutoBackbone.from_pretrained(_a							,use_timm_backbone=_a       )
     _a				:	List[Any]			=   AutoBackbone.from_pretrained(_a       )

     self.assertEqual(len(timm_model.out_features       )							,len(transformers_model.out_features       )       )
     self.assertEqual(len(timm_model.stage_names       )							,len(transformers_model.stage_names       )       )
     self.assertEqual(timm_model.channels							,transformers_model.channels       )
     # Out indices are set to the last layer by default. For timm models, we don't know
     # the number of layers in advance, so we set it to (-1,), whereas for transformers
     # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
     self.assertEqual(timm_model.out_indices							,(-1,)       )
     self.assertEqual(transformers_model.out_indices							,[len(timm_model.stage_names       ) - 1]       )

     _a				:	Union[str, Any]			=   AutoBackbone.from_pretrained(_a							,use_timm_backbone=_a							,out_indices=[1, 2, 3]       )
     _a				:	List[str]			=   AutoBackbone.from_pretrained(_a							,out_indices=[1, 2, 3]       )

     self.assertEqual(timm_model.out_indices							,transformers_model.out_indices       )
     self.assertEqual(len(timm_model.out_features       )							,len(transformers_model.out_features       )       )
     self.assertEqual(timm_model.channels							,transformers_model.channels       )


  @unittest.skip('TimmBackbone doesn\'t support feed forward chunking'       )
  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     pass


  @unittest.skip('TimmBackbone doesn\'t have num_hidden_layers attribute'       )
  def   __lowercase		(		self      :     Optional[int]       ):


     '''simple docstring'''






     pass


  @unittest.skip('TimmBackbone initialization is managed on the timm side'       )
  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     pass


  @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'       )
  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     pass


  @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'       )
  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     pass


  @unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'       )
  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     pass


  @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'       )
  def   __lowercase		(		self      :     int       ):


     '''simple docstring'''






     pass


  @unittest.skip('model weights aren\'t tied in TimmBackbone.'       )
  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     pass


  @unittest.skip('model weights aren\'t tied in TimmBackbone.'       )
  def   __lowercase		(		self      :     List[str]       ):


     '''simple docstring'''






     pass


  @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'       )
  def   __lowercase		(		self      :     Tuple       ):


     '''simple docstring'''






     pass


  @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'       )
  def   __lowercase		(		self      :     Optional[Any]       ):


     '''simple docstring'''






     pass


  @unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'       )
  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     pass


  @unittest.skip('TimmBackbone doesn\'t support output_attentions.'       )
  def   __lowercase		(		self      :     List[Any]       ):


     '''simple docstring'''






     pass


  @unittest.skip('Safetensors is not supported by timm.'       )
  def   __lowercase		(		self      :     Any       ):


     '''simple docstring'''






     pass


  @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'       )
  def   __lowercase		(		self      :     Optional[int]       ):


     '''simple docstring'''






     pass


  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






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

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

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


  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     _a				:	Union[str, Any]			=   self.model_tester.prepare_config_and_inputs_for_common()
     _a				:	Any			=   True
     _a				:	List[str]			=   self.has_attentions

     # no need to test all models as different heads yield the same functionality
     _a				:	Optional[int]			=   self.all_model_classes[0]
     _a				:	Union[str, Any]			=   model_class(_a       )
     model.to(_a       )

     _a				:	List[str]			=   self._prepare_for_class(_a							,_a       )
     _a				:	int			=   model(**_a       )
     _a				:	int			=   outputs[0][-1]

     # Encoder-/Decoder-only models
     _a				:	Any			=   outputs.hidden_states[0]
     hidden_states.retain_grad()

     if self.has_attentions:
        _a				:	int			=   outputs.attentions[0]
        attentions.retain_grad()

     output.flatten()[0].backward(retain_graph=_a       )

     self.assertIsNotNone(hidden_states.grad       )

     if self.has_attentions:
        self.assertIsNotNone(attentions.grad       )


  def   __lowercase		(		self      :     Dict       ):


     '''simple docstring'''






     _a				:	List[str]			=   self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        _a				:	Optional[Any]			=   model_class(_a       )
        model.to(_a       )
        model.eval()
        _a				:	Union[str, Any]			=   model(**_a       )

        self.assertEqual(len(result.feature_maps       )							,len(config.out_indices       )       )
        self.assertEqual(len(model.channels       )							,len(config.out_indices       )       )

        # Check output of last stage is taken if out_features=None, out_indices=None
        _a				:	str			=   copy.deepcopy(_a       )
        _a				:	str			=   None
        _a				:	List[Any]			=   model_class(_a       )
        model.to(_a       )
        model.eval()
        _a				:	Optional[int]			=   model(**_a       )

        self.assertEqual(len(result.feature_maps       )							,1       )
        self.assertEqual(len(model.channels       )							,1       )

        # Check backbone can be initialized with fresh weights
        _a				:	int			=   copy.deepcopy(_a       )
        _a				:	Dict			=   False
        _a				:	Dict			=   model_class(_a       )
        model.to(_a       )
        model.eval()
        _a				:	List[str]			=   model(**_a       )





"""simple docstring"""




# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re

from ..utils import cached_file


# docstyle-ignore
_A			:       Optional[int]   		=       """
Human: <<task>>

Assistant: """


_A			:       List[Any]   		=       """huggingface-tools/default-prompts"""
_A			:       Optional[int]   		=       {"""chat""": """chat_prompt_template.txt""", """run""": """run_prompt_template.txt"""}


def   __magic_name__	(      __snake_case				:       int     , __snake_case				:       List[Any]     , __snake_case				:       Dict="run"  ) ->				Union[str, Any]:
       if prompt_or_repo_id is None:
              lowercase    :				List[Any]       		=							DEFAULT_PROMPTS_REPO

       # prompt is considered a repo ID when it does not contain any kind of space
       if re.search("\\s"     , __snake_case  ) is not None:
              return prompt_or_repo_id

       lowercase    :				Optional[int]       		=							cached_file(
           __snake_case     , PROMPT_FILES[mode]     , repo_type="dataset"     , user_agent={"agent": agent_name}  )
       with open(__snake_case     , "r"     , encoding="utf-8"  ) as f:
              return f.read()


