code: 
  
  
  
  '''simple docstring'''
  
  
  
  import inspect
  import unittest
  
  from transformers import ResNetConfig
  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 torch import nn
  
   from transformers import ResNetBackbone, ResNetForImageClassification, ResNetModel
   from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  if is_vision_available():
   from PIL import Image
  
   from transformers import AutoImageProcessor
  class        UpperCAmelCase__  :
  
  
  
   def __init__(  self		,	lowercase		,	lowercase=3		,	lowercase=3_2		,	lowercase=3		,	lowercase=1_0		,	lowercase=[1_0, 2_0, 3_0, 4_0]		,	lowercase=[1, 1, 2, 1]		,	lowercase=True		,	lowercase=True		,	lowercase="relu"		,	lowercase=3		,	lowercase=None		,	lowercase=["stage2", "stage3", "stage4"]		,	lowercase=[2, 3, 4]		,	)  ->							Optional[int]:
    __UpperCamelCase				      =  parent
    __UpperCamelCase				      =  batch_size
    __UpperCamelCase				      =  image_size
    __UpperCamelCase				      =  num_channels
    __UpperCamelCase				      =  embeddings_size
    __UpperCamelCase				      =  hidden_sizes
    __UpperCamelCase				      =  depths
    __UpperCamelCase				      =  is_training
    __UpperCamelCase				      =  use_labels
    __UpperCamelCase				      =  hidden_act
    __UpperCamelCase				      =  num_labels
    __UpperCamelCase				      =  scope
    __UpperCamelCase				      =  len(lowercase			)
    __UpperCamelCase				      =  out_features
    __UpperCamelCase				      =  out_indices
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Dict:
    __UpperCamelCase				      =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)
  
    __UpperCamelCase				      =  None
    if self.use_labels:
     __UpperCamelCase				      =  ids_tensor([self.batch_size]		,	self.num_labels			)
  
    __UpperCamelCase				      =  self.get_config()
  
    return config, pixel_values, labels
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Tuple:
    return ResNetConfig(
        num_channels=self.num_channels		,	embeddings_size=self.embeddings_size		,	hidden_sizes=self.hidden_sizes		,	depths=self.depths		,	hidden_act=self.hidden_act		,	num_labels=self.num_labels		,	out_features=self.out_features		,	out_indices=self.out_indices		,	)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase			)  ->							Optional[int]:
    __UpperCamelCase				      =  ResNetModel(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase			)
    # 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 // 3_2, self.image_size // 3_2)		,	)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase			)  ->							Union[str, Any]:
    __UpperCamelCase				      =  self.num_labels
    __UpperCamelCase				      =  ResNetForImageClassification(lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase		,	labels=lowercase			)
    self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.num_labels)			)
  
  
  
   def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase			)  ->							Tuple:
    __UpperCamelCase				      =  ResNetBackbone(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase			)
  
    # verify feature maps
    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
    __UpperCamelCase				      =  None
    __UpperCamelCase				      =  ResNetBackbone(config=lowercase			)
    model.to(lowercase			)
    model.eval()
    __UpperCamelCase				      =  model(lowercase			)
  
    # 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    __lowerCamelCase				(  self			)  ->							int:
    __UpperCamelCase				      =  self.prepare_config_and_inputs()
    __UpperCamelCase      ,		__UpperCamelCase      ,		__UpperCamelCase				      =  config_and_inputs
    __UpperCamelCase				      =  {"""pixel_values""": pixel_values}
    return config, inputs_dict
  
  
  @require_torch
  class        UpperCAmelCase__  (    UpperCAmelCase_							,			UpperCAmelCase_							,			unittest.TestCase):
   __SCREAMING_SNAKE_CASE					      =				(
       (
           ResNetModel,
           ResNetForImageClassification,
           ResNetBackbone,
       )
       if is_torch_available()
       else ()
   )
   __SCREAMING_SNAKE_CASE					      =				(
       {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
       if is_torch_available()
       else {}
   )
  
   __SCREAMING_SNAKE_CASE					      =				True
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				False
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Optional[Any]:
    __UpperCamelCase				      =  ResNetModelTester(self			)
    __UpperCamelCase				      =  ConfigTester(self		,	config_class=lowercase		,	has_text_modality=lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							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    __lowerCamelCase				(  self			)  ->							List[str]:
    return
  
  
  
   @unittest.skip(reason="""ResNet does not use inputs_embeds"""			)
   def    __lowerCamelCase				(  self			)  ->							List[Any]:
    pass
  
  
  
   @unittest.skip(reason="""ResNet does not support input and output embeddings"""			)
   def    __lowerCamelCase				(  self			)  ->							Optional[int]:
    pass
  
  
  
   def    __lowerCamelCase				(  self			)  ->							int:
    __UpperCamelCase      ,		__UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs_for_common()
  
    for model_class in self.all_model_classes:
     __UpperCamelCase				      =  model_class(lowercase			)
     __UpperCamelCase				      =  inspect.signature(model.forward			)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     __UpperCamelCase				      =  [*signature.parameters.keys()]
  
     __UpperCamelCase				      =  ["""pixel_values"""]
     self.assertListEqual(arg_names[:1]		,	lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							List[str]:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Dict:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*lowercase			)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Optional[Any]:
    __UpperCamelCase      ,		__UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs_for_common()
  
    for model_class in self.all_model_classes:
     __UpperCamelCase				      =  model_class(config=lowercase			)
     for name, module in model.named_modules():
      if isinstance(lowercase		,	(nn.BatchNormad, nn.GroupNorm)			):
       self.assertTrue(
           torch.all(module.weight == 1			)		,	msg=f"Parameter {name} of model {model_class} seems not properly initialized"		,	)
       self.assertTrue(
           torch.all(module.bias == 0			)		,	msg=f"Parameter {name} of model {model_class} seems not properly initialized"		,	)
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Any:
    def check_hidden_states_output(lowercase		,	lowercase		,	lowercase			):
     __UpperCamelCase				      =  model_class(lowercase			)
     model.to(lowercase			)
     model.eval()
  
     with torch.no_grad():
      __UpperCamelCase				      =  model(**self._prepare_for_class(lowercase		,	lowercase			)			)
  
     __UpperCamelCase				      =  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
  
     __UpperCamelCase				      =  self.model_tester.num_stages
     self.assertEqual(len(lowercase			)		,	expected_num_stages + 1			)
  
     # ResNet'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]		,	)
  
    __UpperCamelCase      ,		__UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs_for_common()
    __UpperCamelCase				      =  ["""basic""", """bottleneck"""]
    for model_class in self.all_model_classes:
     for layer_type in layers_type:
      __UpperCamelCase				      =  layer_type
      __UpperCamelCase				      =  True
      check_hidden_states_output(lowercase		,	lowercase		,	lowercase			)
  
      # check that output_hidden_states also work using config
      del inputs_dict["output_hidden_states"]
      __UpperCamelCase				      =  True
  
      check_hidden_states_output(lowercase		,	lowercase		,	lowercase			)
  
  
  
   @unittest.skip(reason="""ResNet does not use feedforward chunking"""			)
   def    __lowerCamelCase				(  self			)  ->							str:
    pass
  
  
  
   def    __lowerCamelCase				(  self			)  ->							Union[str, Any]:
    __UpperCamelCase				      =  self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*lowercase			)
  
  
  
  
   @slow
   def    __lowerCamelCase				(  self			)  ->							Optional[int]:
    for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     __UpperCamelCase				      =  ResNetModel.from_pretrained(lowercase			)
     self.assertIsNotNone(lowercase			)
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
   return image
  @require_torch
  @require_vision
  class        UpperCAmelCase__  (    unittest.TestCase):
  
  
  
   @cached_property
   def    __lowerCamelCase				(  self			)  ->							Optional[Any]:
    return (
        AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
        if is_vision_available()
        else None
    )
  
  
  
  
   @slow
   def    __lowerCamelCase				(  self			)  ->							List[Any]:
    __UpperCamelCase				      =  ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			).to(lowercase			)
  
    __UpperCamelCase				      =  self.default_image_processor
    __UpperCamelCase				      =  prepare_img()
    __UpperCamelCase				      =  image_processor(images=lowercase		,	return_tensors="""pt"""			).to(lowercase			)
  
    # forward pass
    with torch.no_grad():
     __UpperCamelCase				      =  model(**lowercase			)
  
    # verify the logits
    __UpperCamelCase				      =  torch.Size((1, 1_0_0_0)			)
    self.assertEqual(outputs.logits.shape		,	lowercase			)
  
    __UpperCamelCase				      =  torch.tensor([-11.1_069, -9.7_877, -8.3_777]			).to(lowercase			)
  
    self.assertTrue(torch.allclose(outputs.logits[0, :3]		,	lowercase		,	atol=1E-4			)			)
  
  
  @require_torch
  class        UpperCAmelCase__  (    UpperCAmelCase_							,			unittest.TestCase):
   __SCREAMING_SNAKE_CASE					      =				(ResNetBackbone,) if is_torch_available() else ()
   __SCREAMING_SNAKE_CASE					      =				False
   __SCREAMING_SNAKE_CASE					      =				ResNetConfig
  
  
  
   def    __lowerCamelCase				(  self			)  ->							int:
    __UpperCamelCase				      =  ResNetModelTester(self			)
  
  
  
  
  
  
style_context: 
  
  
  
  '''simple docstring'''
  
  
  
  from .stack import Stack
  
  
  
  
  
  
  
  def _lowercase   (  __A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  Stack()
   __UpperCamelCase				      =  {"""(""": """)""", """[""": """]""", """{""": """}"""}
   for bracket in parentheses:
    if bracket in bracket_pairs:
     stack.push(__A       )
    elif bracket in (")", "]", "}"):
     if stack.is_empty() or bracket_pairs[stack.pop()] != bracket:
      return False
   return stack.is_empty()
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod()
  
   a__						:			List[Any]										=			['((()))', '((())', '(()))']
   print('Balanced parentheses demonstration:\n')
   for example in examples:
    a__						:			int										=			'' if balanced_parentheses(example) else 'not '
    print(f'''{example} is {not_str}balanced''')
  
  
  
  
  
  