

'''simple docstring'''


from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import TFResNetForImageClassification, TFResNetModel
    from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor




class 					lowerCamelCase__:

 def __init__(      self			,							__UpperCAmelCase			,							__UpperCAmelCase=3			,							__UpperCAmelCase=3_2			,							__UpperCAmelCase=3			,							__UpperCAmelCase=1_0			,							__UpperCAmelCase=[1_0, 2_0, 3_0, 4_0]			,							__UpperCAmelCase=[1, 1, 2, 1]			,							__UpperCAmelCase=True			,							__UpperCAmelCase=True			,							__UpperCAmelCase="relu"			,							__UpperCAmelCase=3			,							__UpperCAmelCase=None			,							):



    """simple docstring"""







    __lowercase							      =				parent
    __lowercase							      =				batch_size
    __lowercase							      =				image_size
    __lowercase							      =				num_channels
    __lowercase							      =				embeddings_size
    __lowercase							      =				hidden_sizes
    __lowercase							      =				depths
    __lowercase							      =				is_training
    __lowercase							      =				use_labels
    __lowercase							      =				hidden_act
    __lowercase							      =				num_labels
    __lowercase							      =				scope
    __lowercase							      =				len(_SCREAMING_SNAKE_CASE	)

 def   __magic_name__						(      self	):



    """simple docstring"""







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

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

    __lowercase							      =				self.get_config()

    return config, pixel_values, labels

 def   __magic_name__						(      self	):



    """simple docstring"""







    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			,							image_size=self.image_size			,							)

 def   __magic_name__						(      self			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase	):



    """simple docstring"""







    __lowercase							      =				TFResNetModel(config=_SCREAMING_SNAKE_CASE	)
    __lowercase							      =				model(_SCREAMING_SNAKE_CASE	)
    # 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   __magic_name__						(      self			,							__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase	):



    """simple docstring"""







    __lowercase							      =				self.num_labels
    __lowercase							      =				TFResNetForImageClassification(_SCREAMING_SNAKE_CASE	)
    __lowercase							      =				model(_SCREAMING_SNAKE_CASE			,							labels=_SCREAMING_SNAKE_CASE	)
    self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_labels)	)




 def   __magic_name__						(      self	):



    """simple docstring"""







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





@require_tf
class 					lowerCamelCase__(    __lowerCAmelCase     ,  __lowerCAmelCase     ,  unittest.TestCase		):
 UpperCamelCase			:						Any   							=       (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
 UpperCamelCase			:						List[str]   							=       (
     {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
     if is_tf_available()
     else {}
 )

 UpperCamelCase			:						Dict   							=       False
 UpperCamelCase			:						Optional[Any]   							=       False
 UpperCamelCase			:						Optional[Any]   							=       False
 UpperCamelCase			:						str   							=       False
 UpperCamelCase			:						Optional[Any]   							=       False

 def   __magic_name__						(      self	):



    """simple docstring"""







    __lowercase							      =				TFResNetModelTester(self	)
    __lowercase							      =				ConfigTester(self			,							config_class=_SCREAMING_SNAKE_CASE			,							has_text_modality=_SCREAMING_SNAKE_CASE	)

 def   __magic_name__						(      self	):



    """simple docstring"""







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



    """simple docstring"""







    return

 @unittest.skip(reason="""ResNet does not use inputs_embeds"""	)
 def   __magic_name__						(      self	):



    """simple docstring"""







    pass

 @unittest.skip(reason="""ResNet does not support input and output embeddings"""	)
 def   __magic_name__						(      self	):



    """simple docstring"""







    pass

 def   __magic_name__						(      self	):



    """simple docstring"""







    __lowercase      ,				__lowercase							      =				self.model_tester.prepare_config_and_inputs_for_common()

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

       __lowercase							      =				["""pixel_values"""]
       self.assertListEqual(arg_names[:1]			,							_SCREAMING_SNAKE_CASE	)

 def   __magic_name__						(      self	):



    """simple docstring"""







    __lowercase							      =				self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE	)

 def   __magic_name__						(      self	):



    """simple docstring"""







    def check_hidden_states_output(__UpperCAmelCase			,							__UpperCAmelCase			,							__UpperCAmelCase	):
       __lowercase							      =				model_class(_SCREAMING_SNAKE_CASE	)
       __lowercase							      =				model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE			,							_SCREAMING_SNAKE_CASE	)	)

       __lowercase							      =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

       __lowercase							      =				self.model_tester.num_stages
       self.assertEqual(len(_SCREAMING_SNAKE_CASE	)			,							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]			,							)

    __lowercase      ,				__lowercase							      =				self.model_tester.prepare_config_and_inputs_for_common()
    __lowercase							      =				["""basic""", """bottleneck"""]
    for model_class in self.all_model_classes:
       for layer_type in layers_type:
          __lowercase							      =				layer_type
          __lowercase							      =				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"]
          __lowercase							      =				True

          check_hidden_states_output(_SCREAMING_SNAKE_CASE			,							_SCREAMING_SNAKE_CASE			,							_SCREAMING_SNAKE_CASE	)

 def   __magic_name__						(      self	):



    """simple docstring"""







    __lowercase							      =				self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE	)




 @slow
 def   __magic_name__						(      self	):



    """simple docstring"""







    for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowercase							      =				TFResNetModel.from_pretrained(_SCREAMING_SNAKE_CASE	)
       self.assertIsNotNone(_SCREAMING_SNAKE_CASE	)







def 			lowercase__			(					):




   '''simple docstring'''





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




@require_tf
@require_vision
class 					lowerCamelCase__(    unittest.TestCase		):

 @cached_property
 def   __magic_name__						(      self	):



    """simple docstring"""







    return (
        AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)
        if is_vision_available()
        else None
    )




 @slow
 def   __magic_name__						(      self	):



    """simple docstring"""







    __lowercase							      =				TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)

    __lowercase							      =				self.default_image_processor
    __lowercase							      =				prepare_img()
    __lowercase							      =				image_processor(images=_SCREAMING_SNAKE_CASE			,							return_tensors="""tf"""	)

    # forward pass
    __lowercase							      =				model(**_SCREAMING_SNAKE_CASE	)

    # verify the logits
    __lowercase							      =				tf.TensorShape((1, 1_0_0_0)	)
    self.assertEqual(outputs.logits.shape			,							_SCREAMING_SNAKE_CASE	)

    __lowercase							      =				tf.constant([-1_1.1_0_6_9, -9.78_77, -8.37_77]	)

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









'''simple docstring'''





from __future__ import annotations

import collections
import pprint
from pathlib import Path





def       __a      (  _UpperCamelCase:       str       )		->					str:

     """simple docstring"""




     return "".join(sorted(_UpperCamelCase       )       )





def       __a      (  _UpperCamelCase:       str       )		->					list[str]:

     """simple docstring"""




     return word_by_signature[signature(_UpperCamelCase       )]


UpperCamelCase_		:     str          =		Path(__file__).parent.joinpath('''words.txt''').read_text(encoding='''utf-8''')
UpperCamelCase_		:     Dict          =		sorted({word.strip().lower() for word in data.splitlines()})

UpperCamelCase_		:     Optional[Any]          =		collections.defaultdict(list)
for word in word_list:
   word_by_signature[signature(word)].append(word)

if __name__ == "__main__":
   UpperCamelCase_		:     List[str]          =		{word: anagram(word) for word in word_list if len(anagram(word)) > 1}

   with open('''anagrams.txt''', '''w''') as file:
      file.write('''all_anagrams = \n ''')
      file.write(pprint.pformat(all_anagrams))


