





from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
    import tensorflow as tf

    from transformers import (
        TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFTransfoXLForSequenceClassification,
        TFTransfoXLLMHeadModel,
        TFTransfoXLModel,
    )

class 		SCREAMING_SNAKE_CASE__    :


      def __init__(self	:				List[str]    ,      a__	:				Tuple    ,      ):





         """simple docstring"""



         __snake_case								=       parent
         __snake_case								=       13
         __snake_case								=       7
         __snake_case								=       30
         __snake_case								=       self.seq_length + self.mem_len
         __snake_case								=       15
         __snake_case								=       True
         __snake_case								=       True
         __snake_case								=       99
         __snake_case								=       [10, 50, 80]
         __snake_case								=       32
         __snake_case								=       32
         __snake_case								=       4
         __snake_case								=       8
         __snake_case								=       128
         __snake_case								=       2
         __snake_case								=       2
         __snake_case								=       None
         __snake_case								=       1
         __snake_case								=       0
         __snake_case								=       3
         __snake_case								=       self.vocab_size - 1
         __snake_case								=       0.0_1


      def        a			(self	:				Dict				):





         """simple docstring"""



         __snake_case								=       ids_tensor([self.batch_size, self.seq_length]    ,      self.vocab_size				)
         __snake_case								=       ids_tensor([self.batch_size, self.seq_length]    ,      self.vocab_size				)

         __snake_case								=       None
         if self.use_labels:
            __snake_case								=       ids_tensor([self.batch_size, self.seq_length]    ,      self.vocab_size				)

         __snake_case								=       TransfoXLConfig(
             vocab_size=self.vocab_size    ,      mem_len=self.mem_len    ,      clamp_len=self.clamp_len    ,      cutoffs=self.cutoffs    ,      d_model=self.hidden_size    ,      d_embed=self.d_embed    ,      n_head=self.num_attention_heads    ,      d_head=self.d_head    ,      d_inner=self.d_inner    ,      div_val=self.div_val    ,      n_layer=self.num_hidden_layers    ,      eos_token_id=self.eos_token_id    ,      pad_token_id=self.vocab_size - 1    ,      init_range=self.init_range    ,      num_labels=self.num_labels    ,      )

         return (config, input_ids_a, input_ids_a, lm_labels)


      def        a			(self	:				List[Any]				):





         """simple docstring"""



         random.seed(self.seed				)
         tf.random.set_seed(self.seed				)


      def        a			(self	:				List[Any]    ,      a__	:				List[Any]    ,      a__	:				Tuple    ,      a__	:				str    ,      a__	:				List[Any]				):





         """simple docstring"""



         __snake_case								=       TFTransfoXLModel(a__				)

         __snake_case	,     __snake_case								=       model(a__				).to_tuple()

         __snake_case								=       {'''input_ids''': input_ids_a, '''mems''': mems_a}

         __snake_case	,     __snake_case								=       model(a__				).to_tuple()

         self.parent.assertEqual(hidden_states_a.shape    ,      (self.batch_size, self.seq_length, self.hidden_size)				)
         self.parent.assertEqual(hidden_states_a.shape    ,      (self.batch_size, self.seq_length, self.hidden_size)				)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]    ,      [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers    ,      )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]    ,      [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers    ,      )


      def        a			(self	:				List[Any]    ,      a__	:				List[Any]    ,      a__	:				int    ,      a__	:				Dict    ,      a__	:				int				):





         """simple docstring"""



         __snake_case								=       TFTransfoXLLMHeadModel(a__				)

         __snake_case	,     __snake_case								=       model(a__				).to_tuple()

         __snake_case								=       {'''input_ids''': input_ids_a, '''labels''': lm_labels}
         __snake_case	,     __snake_case								=       model(a__				).to_tuple()

         __snake_case	,     __snake_case								=       model([input_ids_a, mems_a]				).to_tuple()

         __snake_case								=       {'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

         __snake_case	,     __snake_case								=       model(a__				).to_tuple()

         self.parent.assertEqual(lm_logits_a.shape    ,      (self.batch_size, self.seq_length, self.vocab_size)				)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]    ,      [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers    ,      )

         self.parent.assertEqual(lm_logits_a.shape    ,      (self.batch_size, self.seq_length, self.vocab_size)				)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]    ,      [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers    ,      )


      def        a			(self	:				Dict    ,      a__	:				List[str]    ,      a__	:				Optional[Any]    ,      a__	:				str    ,      a__	:				Tuple				):





         """simple docstring"""



         __snake_case								=       TFTransfoXLForSequenceClassification(a__				)
         __snake_case								=       model(a__				)
         self.parent.assertEqual(result.logits.shape    ,      (self.batch_size, self.num_labels)				)


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         __snake_case								=       self.prepare_config_and_inputs()
         ((__snake_case)	,     (__snake_case)	,     (__snake_case)	,     (__snake_case))								=       config_and_inputs
         __snake_case								=       {'''input_ids''': input_ids_a}
         return config, inputs_dict






@require_tf
class 		SCREAMING_SNAKE_CASE__    (	_UpperCAmelCase						,				_UpperCAmelCase						,				unittest.TestCase  ):
      A_						:    Optional[Any]							=   (
          (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
      )
      A_						:    Tuple							=   () if is_tf_available() else ()
      A_						:    Tuple							=   (
          {
              'feature-extraction': TFTransfoXLModel,
              'text-classification': TFTransfoXLForSequenceClassification,
              'text-generation': TFTransfoXLLMHeadModel,
              'zero-shot': TFTransfoXLForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
      A_						:    List[str]							=   False
      A_						:    Optional[int]							=   False
      A_						:    Optional[int]							=   False
      A_						:    Optional[Any]							=   False


      def        a			(self	:				Optional[Any]    ,      a__	:				Any    ,      a__	:				List[str]    ,      a__	:				List[str]    ,      a__	:				str    ,      a__	:				Union[str, Any]				):





         """simple docstring"""



         if pipeline_test_casse_name == "TextGenerationPipelineTests":
            # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
            # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
            # tokenizer.
            return True

         return False


      def        a			(self	:				Dict				):





         """simple docstring"""



         __snake_case								=       TFTransfoXLModelTester(self				)
         __snake_case								=       ConfigTester(self    ,      config_class=a__    ,      d_embed=37				)


      def        a			(self	:				str				):





         """simple docstring"""



         self.config_tester.run_common_tests()


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





         """simple docstring"""



         self.model_tester.set_seed()
         __snake_case								=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*a__				)


      def        a			(self	:				str				):





         """simple docstring"""



         self.model_tester.set_seed()
         __snake_case								=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*a__				)


      def        a			(self	:				Dict				):





         """simple docstring"""



         __snake_case								=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*a__				)


      def        a			(self	:				Any				):





         """simple docstring"""



         __snake_case	,     __snake_case								=       self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case								=       [TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
            __snake_case								=       model_class(a__				)
            assert isinstance(model.get_input_embeddings()    ,      tf.keras.layers.Layer				)
            if model_class in list_other_models_with_output_ebd:
               __snake_case								=       model.get_output_embeddings()
               assert isinstance(a__    ,      tf.keras.layers.Layer				)
               __snake_case								=       model.get_bias()
               assert name is None
            else:
               __snake_case								=       model.get_output_embeddings()
               assert x is None
               __snake_case								=       model.get_bias()
               assert name is None


      def        a			(self	:				Any				):





         """simple docstring"""



         pass


      @slow
      def        a			(self	:				Dict				):





         """simple docstring"""



         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __snake_case								=       TFTransfoXLModel.from_pretrained(a__				)
            self.assertIsNotNone(a__				)


      @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''				)
      def        a			(self	:				Tuple				):





         """simple docstring"""



         pass






@require_tf
class 		SCREAMING_SNAKE_CASE__    (	unittest.TestCase  ):


      @unittest.skip('''Skip test until #12651 is resolved.'''				)
      @slow
      def        a			(self	:				Dict				):





         """simple docstring"""



         __snake_case								=       TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''				)
         # fmt: off
         __snake_case								=       tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0]]    ,      dtype=tf.intaa				)  # noqa: E231
         # fmt: on
         #  In 1991 , the remains of Russian Tsar Nicholas II and his family
         #  ( except for Alexei and Maria ) are discovered .
         #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
         #  remainder of the story . 1883 Western Siberia ,
         #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
         #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
         #  father initially slaps him for making such an accusation , Rasputin watches as the
         #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
         #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
         #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

         # fmt: off
         __snake_case								=       [33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,0]  # noqa: E231
         # fmt: on
         #  In 1991, the remains of Russian Tsar Nicholas II and his family (
         #  except for Alexei and Maria ) are discovered. The voice of young son,
         #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
         #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
         #  and a group of men to perform magic. Rasputin has a vision and
         #  denounces one of the men as a horse thief. Although his father initially
         #  slaps him for making such an accusation, Rasputin watches as the man
         #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
         #  of the Virgin Mary, prompting him to become a priest.
         #  Rasputin quickly becomes famous, with people, even a bishop, begging for
         #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
         # Nicholas II and his family were discovered. The voice of <unk> young son,
         # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

         __snake_case								=       model.generate(a__    ,      max_length=200    ,      do_sample=a__				)
         self.assertListEqual(output_ids[0].numpy().tolist()    ,      a__				)








from __future__ import annotations

import collections
import pprint
from pathlib import Path






def lowerCamelCase__   (							snake_case_     :  str	)				->    str:
   return "".join(sorted(snake_case_	)	)






def lowerCamelCase__   (							snake_case_     :  str	)				->    list[str]:
   return word_by_signature[signature(snake_case_	)]


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

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

if __name__ == "__main__":
    snake_case_           =      {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))

