

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

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






   '''simple docstring'''
   UpperCAmelCase__       :	Union[str, Any]        =       parent
   UpperCAmelCase__       :	List[Any]        =       out_indices if out_indices is not None else [4]
   UpperCAmelCase__       :	Union[str, Any]        =       stage_names
   UpperCAmelCase__       :	Optional[Any]        =       out_features
   UpperCAmelCase__       :	List[Any]        =       backbone
   UpperCAmelCase__       :	str        =       batch_size
   UpperCAmelCase__       :	Union[str, Any]        =       image_size
   UpperCAmelCase__       :	Union[str, Any]        =       num_channels
   UpperCAmelCase__       :	str        =       use_pretrained_backbone
   UpperCAmelCase__       :	Tuple        =       is_training

  def  __lowercase							(	self		:      Optional[Any]     ):






   '''simple docstring'''
   UpperCAmelCase__       :	Union[str, Any]        =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )
   UpperCAmelCase__       :	Optional[int]        =       self.get_config()

   return config, pixel_values

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






   '''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		:      int       ,A		:      Union[str, Any]       ,A		:      List[Any]     ):






   '''simple docstring'''
   UpperCAmelCase__       :	Union[str, Any]        =       TimmBackbone(config=__a     )
   model.to(__a     )
   model.eval()
   with torch.no_grad():
    UpperCAmelCase__       :	List[str]        =       model(__a     )
   self.parent.assertEqual(
       result.feature_map[-1].shape       ,(self.batch_size, model.channels[-1], 14, 14)       ,)




  def  __lowercase							(	self		:      Dict     ):






   '''simple docstring'''
   UpperCAmelCase__       :	List[Any]        =       self.prepare_config_and_inputs()
   UpperCAmelCase__ ,   UpperCAmelCase__       :	int        =       config_and_inputs
   UpperCAmelCase__       :	Tuple        =       {"""pixel_values""": pixel_values}
   return config, inputs_dict







@require_torch
@require_timm
class   __lowercase      (     __lowerCamelCase						,      __lowerCamelCase						,      __lowerCamelCase						,      unittest.TestCase       ):
  snake_case_												=							(TimmBackbone,) if is_torch_available() else ()
  snake_case_												=							{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
  snake_case_												=							False
  snake_case_												=							False
  snake_case_												=							False
  snake_case_												=							False

  def  __lowercase							(	self		:      Optional[int]     ):






   '''simple docstring'''
   UpperCAmelCase__       :	str        =       TimmBackboneModelTester(self     )
   UpperCAmelCase__       :	Optional[int]        =       ConfigTester(self       ,config_class=__a       ,has_text_modality=__a     )

  def  __lowercase							(	self		:      List[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		:      List[str]     ):






   '''simple docstring'''
   UpperCAmelCase__       :	Dict        =       """resnet18"""
   UpperCAmelCase__       :	List[Any]        =       """microsoft/resnet-18"""

   UpperCAmelCase__       :	Union[str, Any]        =       AutoBackbone.from_pretrained(__a       ,use_timm_backbone=__a     )
   UpperCAmelCase__       :	Optional[int]        =       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]     )

   UpperCAmelCase__       :	Optional[Any]        =       AutoBackbone.from_pretrained(__a       ,use_timm_backbone=__a       ,out_indices=[1, 2, 3]     )
   UpperCAmelCase__       :	Union[str, Any]        =       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		:      str     ):






   '''simple docstring'''
   pass

  @unittest.skip("""TimmBackbone doesn\'t have num_hidden_layers attribute"""     )
  def  __lowercase							(	self		:      str     ):






   '''simple docstring'''
   pass

  @unittest.skip("""TimmBackbone initialization is managed on the timm side"""     )
  def  __lowercase							(	self		:      str     ):






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

  @unittest.skip("""model weights aren\'t tied in TimmBackbone."""     )
  def  __lowercase							(	self		:      Union[str, 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		:      str     ):






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

  @unittest.skip("""TimmBackbone doesn\'t have hidden size info in its configuration."""     )
  def  __lowercase							(	self		:      Union[str, Any]     ):






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

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






   '''simple docstring'''
   pass

  def  __lowercase							(	self		:      Optional[Any]     ):






   '''simple docstring'''
   UpperCAmelCase__ ,   UpperCAmelCase__       :	Any        =       self.model_tester.prepare_config_and_inputs_for_common()

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

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

  def  __lowercase							(	self		:      Any     ):






   '''simple docstring'''
   UpperCAmelCase__ ,   UpperCAmelCase__       :	Any        =       self.model_tester.prepare_config_and_inputs_for_common()
   UpperCAmelCase__       :	Union[str, Any]        =       True
   UpperCAmelCase__       :	Optional[Any]        =       self.has_attentions

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

   UpperCAmelCase__       :	Union[str, Any]        =       self._prepare_for_class(__a       ,__a     )
   UpperCAmelCase__       :	List[str]        =       model(**__a     )
   UpperCAmelCase__       :	Tuple        =       outputs[0][-1]

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

   if self.has_attentions:
    UpperCAmelCase__       :	Any        =       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		:      Any     ):






   '''simple docstring'''
   UpperCAmelCase__ ,   UpperCAmelCase__       :	Optional[int]        =       self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
    UpperCAmelCase__       :	Any        =       model_class(__a     )
    model.to(__a     )
    model.eval()
    UpperCAmelCase__       :	str        =       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
    UpperCAmelCase__       :	List[Any]        =       copy.deepcopy(__a     )
    UpperCAmelCase__       :	Dict        =       None
    UpperCAmelCase__       :	Union[str, Any]        =       model_class(__a     )
    model.to(__a     )
    model.eval()
    UpperCAmelCase__       :	int        =       model(**__a     )

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

    # Check backbone can be initialized with fresh weights
    UpperCAmelCase__       :	str        =       copy.deepcopy(__a     )
    UpperCAmelCase__       :	Tuple        =       False
    UpperCAmelCase__       :	Tuple        =       model_class(__a     )
    model.to(__a     )
    model.eval()
    UpperCAmelCase__       :	Union[str, Any]        =       model(**__a     )






'''simple docstring'''


from __future__ import annotations

__lowerCAmelCase						:							List[str]    							=						8.988e9  # units = N * m^s * C^-2





def    lowerCAmelCase       (		UpperCamelCase__					: float     ,       UpperCamelCase__					: float     ,       UpperCamelCase__					: float     ,       UpperCamelCase__					: float							):


	"""simple docstring"""
	__UpperCAmelCase      					=      abs(chargea * chargea							)

	if (force, chargea, chargea, distance).count(0							) != 1:
		raise ValueError('''One and only one argument must be 0'''							)
	if distance < 0:
		raise ValueError('''Distance cannot be negative'''							)
	if force == 0:
		__UpperCAmelCase      					=      COULOMBS_CONSTANT * charge_product / (distance**2)
		return {"force": force}
	elif chargea == 0:
		__UpperCAmelCase      					=      abs(UpperCamelCase__							) * (distance**2) / (COULOMBS_CONSTANT * chargea)
		return {"charge1": chargea}
	elif chargea == 0:
		__UpperCAmelCase      					=      abs(UpperCamelCase__							) * (distance**2) / (COULOMBS_CONSTANT * chargea)
		return {"charge2": chargea}
	elif distance == 0:
		__UpperCAmelCase      					=      (COULOMBS_CONSTANT * charge_product / abs(UpperCamelCase__							)) ** 0.5
		return {"distance": distance}
	raise ValueError('''Exactly one argument must be 0'''							)


if __name__ == "__main__":
					import doctest

					doctest.testmod()
