






'''simple docstring'''



import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY
@is_pipeline_test
@require_torch_or_tf
class 				__SCREAMING_SNAKE_CASE							(				unittest.TestCase  ):
      __a	       =MODEL_FOR_CAUSAL_LM_MAPPING
      __a	       =TF_MODEL_FOR_CAUSAL_LM_MAPPING




      @require_torch
      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         __a					  =     pipeline(task='text-generation'			, model='sshleifer/tiny-ctrl'			, framework='pt'   )
         # Using `do_sample=False` to force deterministic output
         __a					  =     text_generator('This is a test'			, do_sample=lowerCamelCase   )
         self.assertEqual(
             lowerCamelCase			, [
                 {
                     'generated_text': (
                         'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
                         ' oscope. FiliFili@@'
                     )
                 }
             ]			, )

         __a					  =     text_generator(['This is a test', 'This is a second test']   )
         self.assertEqual(
             lowerCamelCase			, [
                 [
                     {
                         'generated_text': (
                             'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
                             ' oscope. FiliFili@@'
                         )
                     }
                 ],
                 [
                     {
                         'generated_text': (
                             'This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'
                             ' oscope. oscope. FiliFili@@'
                         )
                     }
                 ],
             ]			, )

         __a					  =     text_generator('This is a test'			, do_sample=lowerCamelCase			, num_return_sequences=2			, return_tensors=lowerCamelCase   )
         self.assertEqual(
             lowerCamelCase			, [
                 {'generated_token_ids': ANY(lowerCamelCase   )},
                 {'generated_token_ids': ANY(lowerCamelCase   )},
             ]			, )
         __a					  =     text_generator.model.config.eos_token_id
         __a					  =     '<pad>'
         __a					  =     text_generator(
             ['This is a test', 'This is a second test']			, do_sample=lowerCamelCase			, num_return_sequences=2			, batch_size=2			, return_tensors=lowerCamelCase			, )
         self.assertEqual(
             lowerCamelCase			, [
                 [
                     {'generated_token_ids': ANY(lowerCamelCase   )},
                     {'generated_token_ids': ANY(lowerCamelCase   )},
                 ],
                 [
                     {'generated_token_ids': ANY(lowerCamelCase   )},
                     {'generated_token_ids': ANY(lowerCamelCase   )},
                 ],
             ]			, )




      @require_tf
      def 			__UpperCamelCase				(	self   )				->str:



         '''simple docstring'''
         __a					  =     pipeline(task='text-generation'			, model='sshleifer/tiny-ctrl'			, framework='tf'   )

         # Using `do_sample=False` to force deterministic output
         __a					  =     text_generator('This is a test'			, do_sample=lowerCamelCase   )
         self.assertEqual(
             lowerCamelCase			, [
                 {
                     'generated_text': (
                         'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
                         ' please,'
                     )
                 }
             ]			, )

         __a					  =     text_generator(['This is a test', 'This is a second test']			, do_sample=lowerCamelCase   )
         self.assertEqual(
             lowerCamelCase			, [
                 [
                     {
                         'generated_text': (
                             'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
                             ' please,'
                         )
                     }
                 ],
                 [
                     {
                         'generated_text': (
                             'This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'
                             ' Cannes 閲閲Cannes Cannes Cannes 攵 please,'
                         )
                     }
                 ],
             ]			, )




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase   )				->str:



         '''simple docstring'''
         __a					  =     TextGenerationPipeline(model=lowerCamelCase			, tokenizer=lowerCamelCase   )
         return text_generator, ["This is a test", "Another test"]




      def 			__UpperCamelCase				(	self   )				->Any:



         '''simple docstring'''
         __a					  =     'Hello I believe in'
         __a					  =     pipeline('text-generation'			, model='hf-internal-testing/tiny-random-gpt2'   )
         __a					  =     text_generator(lowerCamelCase   )
         self.assertEqual(
             lowerCamelCase			, [{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}]			, )

         __a					  =     text_generator(lowerCamelCase			, stop_sequence=' fe'   )
         self.assertEqual(lowerCamelCase			, [{'generated_text': 'Hello I believe in fe'}]   )




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase   )				->Dict:



         '''simple docstring'''
         __a					  =     text_generator.model
         __a					  =     text_generator.tokenizer

         __a					  =     text_generator('This is a test'   )
         self.assertEqual(lowerCamelCase			, [{'generated_text': ANY(lowerCamelCase   )}]   )
         self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'   )   )

         __a					  =     text_generator('This is a test'			, return_full_text=lowerCamelCase   )
         self.assertEqual(lowerCamelCase			, [{'generated_text': ANY(lowerCamelCase   )}]   )
         self.assertNotIn('This is a test'			, outputs[0]['generated_text']   )

         __a					  =     pipeline(task='text-generation'			, model=lowerCamelCase			, tokenizer=lowerCamelCase			, return_full_text=lowerCamelCase   )
         __a					  =     text_generator('This is a test'   )
         self.assertEqual(lowerCamelCase			, [{'generated_text': ANY(lowerCamelCase   )}]   )
         self.assertNotIn('This is a test'			, outputs[0]['generated_text']   )

         __a					  =     text_generator('This is a test'			, return_full_text=lowerCamelCase   )
         self.assertEqual(lowerCamelCase			, [{'generated_text': ANY(lowerCamelCase   )}]   )
         self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'   )   )

         __a					  =     text_generator(['This is great !', 'Something else']			, num_return_sequences=2			, do_sample=lowerCamelCase   )
         self.assertEqual(
             lowerCamelCase			, [
                 [{'generated_text': ANY(lowerCamelCase   )}, {'generated_text': ANY(lowerCamelCase   )}],
                 [{'generated_text': ANY(lowerCamelCase   )}, {'generated_text': ANY(lowerCamelCase   )}],
             ]			, )

         if text_generator.tokenizer.pad_token is not None:
            __a					  =     text_generator(
                ['This is great !', 'Something else']			, num_return_sequences=2			, batch_size=2			, do_sample=lowerCamelCase   )
            self.assertEqual(
                lowerCamelCase			, [
                    [{'generated_text': ANY(lowerCamelCase   )}, {'generated_text': ANY(lowerCamelCase   )}],
                    [{'generated_text': ANY(lowerCamelCase   )}, {'generated_text': ANY(lowerCamelCase   )}],
                ]			, )

         with self.assertRaises(lowerCamelCase   ):
            __a					  =     text_generator('test'			, return_full_text=lowerCamelCase			, return_text=lowerCamelCase   )
         with self.assertRaises(lowerCamelCase   ):
            __a					  =     text_generator('test'			, return_full_text=lowerCamelCase			, return_tensors=lowerCamelCase   )
         with self.assertRaises(lowerCamelCase   ):
            __a					  =     text_generator('test'			, return_text=lowerCamelCase			, return_tensors=lowerCamelCase   )

         # Empty prompt is slighly special
         # it requires BOS token to exist.
         # Special case for Pegasus which will always append EOS so will
         # work even without BOS.
         if (
             text_generator.tokenizer.bos_token_id is not None
             or "Pegasus" in tokenizer.__class__.__name__
             or "Git" in model.__class__.__name__
         ):
            __a					  =     text_generator(''   )
            self.assertEqual(lowerCamelCase			, [{'generated_text': ANY(lowerCamelCase   )}]   )
         else:
            with self.assertRaises((ValueError, AssertionError)   ):
               __a					  =     text_generator(''   )

         if text_generator.framework == "tf":
            # TF generation does not support max_new_tokens, and it's impossible
            # to control long generation with only max_length without
            # fancy calculation, dismissing tests for now.
            return
         # We don't care about infinite range models.
         # They already work.
         # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
         __a					  =     ['RwkvForCausalLM', 'XGLMForCausalLM', 'GPTNeoXForCausalLM']
         if (
             tokenizer.model_max_length < 1_0000
             and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
         ):
            # Handling of large generations
            with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)   ):
               text_generator('This is a test' * 500			, max_new_tokens=20   )

            __a					  =     text_generator('This is a test' * 500			, handle_long_generation='hole'			, max_new_tokens=20   )
            # Hole strategy cannot work
            with self.assertRaises(lowerCamelCase   ):
               text_generator(
                   'This is a test' * 500			, handle_long_generation='hole'			, max_new_tokens=tokenizer.model_max_length + 10			, )




      @require_torch
      @require_accelerate
      @require_torch_gpu
      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         import torch

         # Classic `model_kwargs`
         __a					  =     pipeline(
             model='hf-internal-testing/tiny-random-bloom'			, model_kwargs={'device_map': 'auto', 'torch_dtype': torch.bfloataa}			, )
         self.assertEqual(pipe.model.device			, torch.device(0   )   )
         self.assertEqual(pipe.model.lm_head.weight.dtype			, torch.bfloataa   )
         __a					  =     pipe('This is a test'   )
         self.assertEqual(
             lowerCamelCase			, [
                 {
                     'generated_text': (
                         'This is a test test test test test test test test test test test test test test test test'
                         ' test'
                     )
                 }
             ]			, )

         # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
         __a					  =     pipeline(model='hf-internal-testing/tiny-random-bloom'			, device_map='auto'			, torch_dtype=torch.bfloataa   )
         self.assertEqual(pipe.model.device			, torch.device(0   )   )
         self.assertEqual(pipe.model.lm_head.weight.dtype			, torch.bfloataa   )
         __a					  =     pipe('This is a test'   )
         self.assertEqual(
             lowerCamelCase			, [
                 {
                     'generated_text': (
                         'This is a test test test test test test test test test test test test test test test test'
                         ' test'
                     )
                 }
             ]			, )

         # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
         __a					  =     pipeline(model='hf-internal-testing/tiny-random-bloom'			, device_map='auto'   )
         self.assertEqual(pipe.model.device			, torch.device(0   )   )
         self.assertEqual(pipe.model.lm_head.weight.dtype			, torch.floataa   )
         __a					  =     pipe('This is a test'   )
         self.assertEqual(
             lowerCamelCase			, [
                 {
                     'generated_text': (
                         'This is a test test test test test test test test test test test test test test test test'
                         ' test'
                     )
                 }
             ]			, )




      @require_torch
      @require_torch_gpu
      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         import torch

         __a					  =     pipeline(model='hf-internal-testing/tiny-random-bloom'			, device=0			, torch_dtype=torch.floataa   )
         pipe('This is a test'   )




      @require_torch
      @require_accelerate
      @require_torch_gpu
      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         import torch

         __a					  =     pipeline(model='hf-internal-testing/tiny-random-bloom'			, device_map='auto'			, torch_dtype=torch.floataa   )
         pipe('This is a test'			, do_sample=lowerCamelCase			, top_p=0.5   )






      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         __a					  =     'Hello world'
         __a					  =     pipeline('text-generation'			, model='hf-internal-testing/tiny-random-gpt2'   )
         if text_generator.model.framework == "tf":
            __a					  =     logging.get_logger('transformers.generation.tf_utils'   )
         else:
            __a					  =     logging.get_logger('transformers.generation.utils'   )
         __a					  =     'Both `max_new_tokens`'  # The beggining of the message to be checked in this test

         # Both are set by the user -> log warning
         with CaptureLogger(lowerCamelCase   ) as cl:
            __a					  =     text_generator(lowerCamelCase			, max_length=10			, max_new_tokens=1   )
         self.assertIn(lowerCamelCase			, cl.out   )

         # The user only sets one -> no warning
         with CaptureLogger(lowerCamelCase   ) as cl:
            __a					  =     text_generator(lowerCamelCase			, max_new_tokens=1   )
         self.assertNotIn(lowerCamelCase			, cl.out   )

         with CaptureLogger(lowerCamelCase   ) as cl:
            __a					  =     text_generator(lowerCamelCase			, max_length=10   )
         self.assertNotIn(lowerCamelCase			, cl.out   )







'''simple docstring'''



from __future__ import annotations

from typing import TypedDict
class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):
      __a	       =42
      __a	       =42







def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      list[str]:

   """simple docstring"""
   if not isinstance(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     ):
      raise TypeError('The parameter s type must be str.'     )

   return [s[i:] + s[:i] for i in range(len(SCREAMING_SNAKE_CASE__     )     )]



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      BWTTransformDict:

   """simple docstring"""
   if not isinstance(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     ):
      raise TypeError('The parameter s type must be str.'     )
   if not s:
      raise ValueError('The parameter s must not be empty.'     )

   __a					  =     all_rotations(SCREAMING_SNAKE_CASE__     )
   rotations.sort()  # sort the list of rotations in alphabetically order
   # make a string composed of the last char of each rotation
   __a					  =     {
       "bwt_string": "".join([word[-1] for word in rotations]     ),
       "idx_original_string": rotations.index(SCREAMING_SNAKE_CASE__     ),
   }
   return response



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str,       SCREAMING_SNAKE_CASE__:						int     )	->      str:

   """simple docstring"""
   if not isinstance(SCREAMING_SNAKE_CASE__,       SCREAMING_SNAKE_CASE__     ):
      raise TypeError('The parameter bwt_string type must be str.'     )
   if not bwt_string:
      raise ValueError('The parameter bwt_string must not be empty.'     )
   try:
      __a					  =     int(SCREAMING_SNAKE_CASE__     )
   except ValueError:
      raise TypeError(
          'The parameter idx_original_string type must be int or passive'
          ' of cast to int.'     )
   if idx_original_string < 0:
      raise ValueError('The parameter idx_original_string must not be lower than 0.'     )
   if idx_original_string >= len(SCREAMING_SNAKE_CASE__     ):
      raise ValueError(
          'The parameter idx_original_string must be lower than' ' len(bwt_string).'     )

   __a					  =     [''] * len(SCREAMING_SNAKE_CASE__     )
   for _ in range(len(SCREAMING_SNAKE_CASE__     )     ):
      for i in range(len(SCREAMING_SNAKE_CASE__     )     ):
         __a					  =     bwt_string[i] + ordered_rotations[i]
      ordered_rotations.sort()
   return ordered_rotations[idx_original_string]


if __name__ == "__main__":
 __UpperCamelCase   :							Any         =   """Provide a string that I will generate its BWT transform: """
 __UpperCamelCase   :							Dict         =   input(entry_msg).strip()
 __UpperCamelCase   :							Optional[int]         =   bwt_transform(s)
 print(
     f"""Burrows Wheeler transform for string '{s}' results """
     f"""in '{result["bwt_string"]}'"""
 )
 __UpperCamelCase   :							Dict         =   reverse_bwt(result["""bwt_string"""], result["""idx_original_string"""])
 print(
     f"""Reversing Burrows Wheeler transform for entry '{result["bwt_string"]}' """
     f"""we get original string '{original_string}'"""
 )