

from __future__ import annotations

import unittest

from transformers import AutoTokenizer, GPTJConfig, is_tf_available
from transformers.testing_utils import require_tf, slow, tooslow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
from ...utils.test_modeling_tf_core import TFCoreModelTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers.models.gptj.modeling_tf_gptj import (
     TFGPTJForCausalLM,
     TFGPTJForQuestionAnswering,
     TFGPTJForSequenceClassification,
     TFGPTJModel,
     shape_list,
 )



class 						a_			:



      """simple docstring"""







      def __init__( self	:				List[Any]     ,snake_case	:				Optional[int]							):
           SCREAMING_SNAKE_CASE 		=parent
           SCREAMING_SNAKE_CASE 		=13
           SCREAMING_SNAKE_CASE 		=7
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=True
           SCREAMING_SNAKE_CASE 		=99
           SCREAMING_SNAKE_CASE 		=32
           SCREAMING_SNAKE_CASE 		=4
           SCREAMING_SNAKE_CASE 		=2
           SCREAMING_SNAKE_CASE 		=4
           SCREAMING_SNAKE_CASE 		=37
           SCREAMING_SNAKE_CASE 		='gelu'
           SCREAMING_SNAKE_CASE 		=0.1
           SCREAMING_SNAKE_CASE 		=0.1
           SCREAMING_SNAKE_CASE 		=512
           SCREAMING_SNAKE_CASE 		=16
           SCREAMING_SNAKE_CASE 		=2
           SCREAMING_SNAKE_CASE 		=0.02
           SCREAMING_SNAKE_CASE 		=3
           SCREAMING_SNAKE_CASE 		=4
           SCREAMING_SNAKE_CASE 		=None
           SCREAMING_SNAKE_CASE 		=self.vocab_size - 1
           SCREAMING_SNAKE_CASE 		=self.vocab_size - 1
           SCREAMING_SNAKE_CASE 		=self.vocab_size - 1
      def 			_lowerCAmelCase	( self	:				Optional[Any]							):
           SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size, self.seq_length]     ,self.vocab_size							)

           SCREAMING_SNAKE_CASE 		=None
           if self.use_input_mask:
                SCREAMING_SNAKE_CASE 		=random_attention_mask([self.batch_size, self.seq_length]							)

           SCREAMING_SNAKE_CASE 		=None
           if self.use_token_type_ids:
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size, self.seq_length]     ,self.type_vocab_size							)

           SCREAMING_SNAKE_CASE 		=None
           if self.use_mc_token_ids:
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size, self.num_choices]     ,self.seq_length							)

           SCREAMING_SNAKE_CASE 		=None
           SCREAMING_SNAKE_CASE 		=None
           SCREAMING_SNAKE_CASE 		=None
           if self.use_labels:
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size]     ,self.type_sequence_label_size							)
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size, self.seq_length]     ,self.num_labels							)
                SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size]     ,self.num_choices							)

           SCREAMING_SNAKE_CASE 		=GPTJConfig(
               vocab_size=self.vocab_size     ,n_embd=self.hidden_size     ,n_layer=self.num_hidden_layers     ,n_head=self.num_attention_heads     ,intermediate_size=self.intermediate_size     ,hidden_act=self.hidden_act     ,hidden_dropout_prob=self.hidden_dropout_prob     ,attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,n_positions=self.max_position_embeddings     ,type_vocab_size=self.type_vocab_size     ,initializer_range=self.initializer_range     ,bos_token_id=self.bos_token_id     ,eos_token_id=self.eos_token_id     ,pad_token_id=self.pad_token_id     ,rotary_dim=self.rotary_dim     ,return_dict=snake_case     ,)

           SCREAMING_SNAKE_CASE 		=ids_tensor([self.num_hidden_layers, self.num_attention_heads]     ,2							)

           return (
               config,
               input_ids,
               input_mask,
               head_mask,
               token_type_ids,
               mc_token_ids,
               sequence_labels,
               token_labels,
               choice_labels,
           )
      def 			_lowerCAmelCase	( self	:				Optional[Any]     ,snake_case	:				str     ,snake_case	:				Union[str, Any]     ,snake_case	:				Optional[Any]     ,snake_case	:				Optional[Any]     ,snake_case	:				Any     ,*snake_case	:				str							):
           SCREAMING_SNAKE_CASE 		=TFGPTJModel(config=snake_case							)
           SCREAMING_SNAKE_CASE 		={
               'input_ids': input_ids,
               'attention_mask': input_mask,
               'token_type_ids': token_type_ids,
           }
           SCREAMING_SNAKE_CASE 		=model(snake_case							)

           SCREAMING_SNAKE_CASE 		=[input_ids, None, input_mask]  # None is the input for 'past'
           SCREAMING_SNAKE_CASE 		=model(snake_case							)

           SCREAMING_SNAKE_CASE 		=model(snake_case							)

           self.parent.assertEqual(result.last_hidden_state.shape     ,(self.batch_size, self.seq_length, self.hidden_size)							)
      def 			_lowerCAmelCase	( self	:				List[Any]     ,snake_case	:				Union[str, Any]     ,snake_case	:				Optional[Any]     ,snake_case	:				Dict     ,snake_case	:				Optional[Any]     ,snake_case	:				Tuple     ,*snake_case	:				str							):
           SCREAMING_SNAKE_CASE 		=TFGPTJModel(config=snake_case							)

           # first forward pass
           SCREAMING_SNAKE_CASE 		=model(snake_case     ,token_type_ids=snake_case     ,use_cache=snake_case							)
           SCREAMING_SNAKE_CASE 		=model(snake_case     ,token_type_ids=snake_case							)
           SCREAMING_SNAKE_CASE 		=model(snake_case     ,token_type_ids=snake_case     ,use_cache=snake_case							)

           self.parent.assertTrue(len(snake_case							) == len(snake_case							)							)
           self.parent.assertTrue(len(snake_case							) == len(snake_case							) + 1							)

           SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE 		=outputs.to_tuple()

           # create hypothetical next token and extent to next_input_ids
           SCREAMING_SNAKE_CASE 		=ids_tensor((self.batch_size, 1)     ,config.vocab_size							)
           SCREAMING_SNAKE_CASE 		=ids_tensor([self.batch_size, 1]     ,self.type_vocab_size							)

           # append to next input_ids and token_type_ids
           SCREAMING_SNAKE_CASE 		=tf.concat([input_ids, next_tokens]     ,axis=-1							)
           SCREAMING_SNAKE_CASE 		=tf.concat([token_type_ids, next_token_types]     ,axis=-1							)

           SCREAMING_SNAKE_CASE 		=model(snake_case     ,token_type_ids=snake_case							)['last_hidden_state']
           SCREAMING_SNAKE_CASE 		=model(snake_case     ,token_type_ids=snake_case     ,past_key_values=snake_case							)[
               'last_hidden_state'
           ]

           # select random slice
           SCREAMING_SNAKE_CASE 		=int(ids_tensor((1,)     ,shape_list(snake_case							)[-1]							)							)
           SCREAMING_SNAKE_CASE 		=output_from_no_past[:, -1, random_slice_idx]
           SCREAMING_SNAKE_CASE 		=output_from_past[:, 0, random_slice_idx]

           # test that outputs are equal for slice
           tf.debugging.assert_near(snake_case     ,snake_case     ,rtol=1e-6							)
      def 			_lowerCAmelCase	( self	:				Union[str, Any]     ,snake_case	:				List[Any]     ,snake_case	:				Optional[Any]     ,snake_case	:				Optional[int]     ,snake_case	:				str     ,snake_case	:				int     ,*snake_case	:				int							):
           SCREAMING_SNAKE_CASE 		=TFGPTJModel(config=snake_case							)

           # create attention mask
           SCREAMING_SNAKE_CASE 		=self.seq_length // 2
           SCREAMING_SNAKE_CASE 		=tf.ones((self.batch_size, half_seq_length)     ,dtype=tf.intaa							)
           SCREAMING_SNAKE_CASE 		=tf.zeros((self.batch_size, self.seq_length - half_seq_length)     ,dtype=tf.intaa							)
           SCREAMING_SNAKE_CASE 		=tf.concat([attn_mask_begin, attn_mask_end]     ,axis=1							)

           # first forward pass
           SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE 		=model(snake_case     ,attention_mask=snake_case							).to_tuple()

           # create hypothetical next token and extent to next_input_ids
           SCREAMING_SNAKE_CASE 		=ids_tensor((self.batch_size, 1)     ,config.vocab_size							)

           # change a random masked slice from input_ids
           SCREAMING_SNAKE_CASE 		=ids_tensor((1,)     ,snake_case							).numpy() + 1
           SCREAMING_SNAKE_CASE 		=ids_tensor((self.batch_size, self.seq_length)     ,config.vocab_size							)
           SCREAMING_SNAKE_CASE 		=tf.range(self.seq_length							) == (self.seq_length - random_seq_idx_to_change)
           SCREAMING_SNAKE_CASE 		=tf.transpose(
               tf.broadcast_to(tf.expand_dims(snake_case     ,-1							)     ,(self.seq_length, self.batch_size)							)							)
           SCREAMING_SNAKE_CASE 		=tf.where(snake_case     ,snake_case     ,snake_case							)

           # append to next input_ids and attn_mask
           SCREAMING_SNAKE_CASE 		=tf.concat([input_ids, next_tokens]     ,axis=-1							)
           SCREAMING_SNAKE_CASE 		=tf.concat([attn_mask, tf.ones((shape_list(snake_case							)[0], 1)     ,dtype=tf.intaa							)]     ,axis=1							)

           # get two different outputs
           SCREAMING_SNAKE_CASE 		=model(snake_case     ,attention_mask=snake_case							)['last_hidden_state']
           SCREAMING_SNAKE_CASE 		=model(snake_case     ,past_key_values=snake_case     ,attention_mask=snake_case							)[
               'last_hidden_state'
           ]

           # select random slice
           SCREAMING_SNAKE_CASE 		=int(ids_tensor((1,)     ,shape_list(snake_case							)[-1]							)							)
           SCREAMING_SNAKE_CASE 		=output_from_no_past[:, -1, random_slice_idx]
           SCREAMING_SNAKE_CASE 		=output_from_past[:, 0, random_slice_idx]

           # test that outputs are equal for slice
           tf.debugging.assert_near(snake_case     ,snake_case     ,rtol=1e-12							)
      def 			_lowerCAmelCase	( self	:				int     ,snake_case	:				Any     ,snake_case	:				List[str]     ,snake_case	:				List[Any]     ,snake_case	:				Tuple     ,snake_case	:				List[str]     ,*snake_case	:				Union[str, Any]							):
           SCREAMING_SNAKE_CASE 		=TFGPTJModel(config=snake_case							)

           SCREAMING_SNAKE_CASE 		=input_ids[:1, :]
           SCREAMING_SNAKE_CASE 		=input_mask[:1, :]
           SCREAMING_SNAKE_CASE 		=token_type_ids[:1, :]
           SCREAMING_SNAKE_CASE 		=1

           # first forward pass
           SCREAMING_SNAKE_CASE 		=model(snake_case     ,attention_mask=snake_case     ,token_type_ids=snake_case     ,use_cache=snake_case							)

           SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE 		=outputs.to_tuple()

           # create hypothetical next token and extent to next_input_ids
           SCREAMING_SNAKE_CASE 		=ids_tensor((self.batch_size, 3)     ,config.vocab_size							)
           SCREAMING_SNAKE_CASE 		=ids_tensor((self.batch_size, 3)     ,2							)
           SCREAMING_SNAKE_CASE 		=ids_tensor((self.batch_size, 3)     ,self.type_vocab_size							)

           # append to next input_ids and token_type_ids
           SCREAMING_SNAKE_CASE 		=tf.concat([input_ids, next_tokens]     ,axis=-1							)
           SCREAMING_SNAKE_CASE 		=tf.concat([input_mask, next_attn_mask]     ,axis=-1							)
           SCREAMING_SNAKE_CASE 		=tf.concat([token_type_ids, next_token_types]     ,axis=-1							)

           SCREAMING_SNAKE_CASE 		=model(
               snake_case     ,token_type_ids=snake_case     ,attention_mask=snake_case							)['last_hidden_state']
           SCREAMING_SNAKE_CASE 		=model(
               snake_case     ,token_type_ids=snake_case     ,attention_mask=snake_case     ,past_key_values=snake_case     ,)['last_hidden_state']
           self.parent.assertTrue(output_from_past.shape[1] == next_tokens.shape[1]							)

           # select random slice
           SCREAMING_SNAKE_CASE 		=int(ids_tensor((1,)     ,shape_list(snake_case							)[-1]							)							)
           SCREAMING_SNAKE_CASE 		=output_from_no_past[:, -3:, random_slice_idx]
           SCREAMING_SNAKE_CASE 		=output_from_past[:, :, random_slice_idx]

           # test that outputs are equal for slice
           tf.debugging.assert_near(snake_case     ,snake_case     ,rtol=1e-3							)
      def 			_lowerCAmelCase	( self	:				Any     ,snake_case	:				Tuple     ,snake_case	:				Tuple     ,snake_case	:				Optional[int]     ,snake_case	:				List[str]     ,snake_case	:				Any     ,*snake_case	:				Any							):
           SCREAMING_SNAKE_CASE 		=TFGPTJForCausalLM(config=snake_case							)
           SCREAMING_SNAKE_CASE 		={
               'input_ids': input_ids,
               'attention_mask': input_mask,
               'token_type_ids': token_type_ids,
           }
           SCREAMING_SNAKE_CASE 		=model(snake_case							)
           self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.seq_length, self.vocab_size)							)


      def 			_lowerCAmelCase	( self	:				List[str]							):
           SCREAMING_SNAKE_CASE 		=self.prepare_config_and_inputs()

           (
               (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    (
               SCREAMING_SNAKE_CASE
           )		,    
           ) 		=config_and_inputs

           SCREAMING_SNAKE_CASE 		={
               'input_ids': input_ids,
               'token_type_ids': token_type_ids,
               'attention_mask': input_mask,
           }
           return config, inputs_dict







@require_tf
class 						a_			(				lowerCamelCase_					,     lowerCamelCase_					,     lowerCamelCase_					,     unittest.TestCase	):



      """simple docstring"""







      __UpperCAmelCase     						= (
          (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
          if is_tf_available()
          else ()
      )

      __UpperCAmelCase     						= (TFGPTJForCausalLM,) if is_tf_available() else ()
      __UpperCAmelCase     						= (
          {
              'feature-extraction': TFGPTJModel,
              'question-answering': TFGPTJForQuestionAnswering,
              'text-classification': TFGPTJForSequenceClassification,
              'text-generation': TFGPTJForCausalLM,
              'zero-shot': TFGPTJForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      __UpperCAmelCase     						= False
      __UpperCAmelCase     						= False
      __UpperCAmelCase     						= False
      __UpperCAmelCase     						= False
      def 			_lowerCAmelCase	( self	:				Dict     ,snake_case	:				Optional[int]     ,snake_case	:				Dict     ,snake_case	:				List[str]     ,snake_case	:				List[str]     ,snake_case	:				str							):
           if (
               pipeline_test_casse_name == "QAPipelineTests"
               and tokenizer_name is not None
               and not tokenizer_name.endswith('Fast'							)
           ):
                # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
                # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
                # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
                return True

           return False
      def 			_lowerCAmelCase	( self	:				Union[str, Any]							):
           SCREAMING_SNAKE_CASE 		=TFGPTJModelTester(self							)
           SCREAMING_SNAKE_CASE 		=ConfigTester(self     ,config_class=snake_case     ,n_embd=37							)
      def 			_lowerCAmelCase	( self	:				List[str]							):
           self.config_tester.run_common_tests()
      def 			_lowerCAmelCase	( self	:				str							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model(*snake_case							)
      def 			_lowerCAmelCase	( self	:				Dict							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model_past(*snake_case							)
      def 			_lowerCAmelCase	( self	:				Tuple							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model_attention_mask_past(*snake_case							)
      def 			_lowerCAmelCase	( self	:				List[Any]							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_model_past_large_inputs(*snake_case							)
      def 			_lowerCAmelCase	( self	:				Dict							):
           SCREAMING_SNAKE_CASE 		=self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_gptj_lm_head_model(*snake_case							)
      @slow
      @unittest.skipIf(
          not is_tf_available() or len(tf.config.list_physical_devices('GPU'							)							) > 0     ,'skip testing on GPU for now to avoid GPU OOM.'     ,)
      def 			_lowerCAmelCase	( self	:				Optional[Any]							):
           SCREAMING_SNAKE_CASE 		=TFGPTJModel.from_pretrained('EleutherAI/gpt-j-6B'     ,from_pt=snake_case							)
           self.assertIsNotNone(snake_case							)


      @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.'							)
      def 			_lowerCAmelCase	( self	:				int							):
           super().test_resize_token_embeddings()







@require_tf
@tooslow
# Marked as @tooslow due to GPU OOM -- but still useful to run locally. Requires ~39GB of RAM.
class 						a_			(				unittest.TestCase	):



      """simple docstring"""







      def 			_lowerCAmelCase	( self	:				Tuple							):
           SCREAMING_SNAKE_CASE 		=TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'     ,from_pt=snake_case							)
           SCREAMING_SNAKE_CASE 		=tf.convert_to_tensor([[464, 3290]]     ,dtype=tf.intaa							)  # The dog
           # fmt: off
           # The dog is a man's best friend. It is a loyal companion, and it is a friend
           SCREAMING_SNAKE_CASE 		=[464, 3290, 318, 257, 582, 338, 1266, 1545, 13, 632, 318, 257, 9112, 15185, 11, 290, 340, 318, 257, 1545]
           # fmt: on
           SCREAMING_SNAKE_CASE 		=model.generate(snake_case     ,do_sample=snake_case							)
           self.assertListEqual(output_ids[0].numpy().tolist()     ,snake_case							)
      def 			_lowerCAmelCase	( self	:				Optional[Any]							):
           SCREAMING_SNAKE_CASE 		=AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'     ,revision='float16'							)
           SCREAMING_SNAKE_CASE 		=TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'     ,revision='float16'     ,from_pt=snake_case							)

           SCREAMING_SNAKE_CASE 		=tokenizer('Today is a nice day and'     ,return_tensors='tf'							)
           # forces the generation to happen on CPU, to avoid GPU-related quirks
           with tf.device(':/CPU:0'							):
                SCREAMING_SNAKE_CASE 		=model.generate(**snake_case     ,do_sample=snake_case     ,seed=[42, 0]							)
           SCREAMING_SNAKE_CASE 		=tokenizer.decode(output_ids[0]     ,skip_special_tokens=snake_case							)

           SCREAMING_SNAKE_CASE 		='Today is a nice day and I’m going to go for a walk. I’'
           self.assertEqual(snake_case     ,snake_case							)
      def 			_lowerCAmelCase	( self	:				Optional[int]							):
           SCREAMING_SNAKE_CASE 		=TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'     ,revision='float16'     ,from_pt=snake_case							)
           SCREAMING_SNAKE_CASE 		=AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'     ,revision='float16'							)

           SCREAMING_SNAKE_CASE 		='left'

           # Define PAD Token = EOS Token = 50256
           SCREAMING_SNAKE_CASE 		=tokenizer.eos_token
           SCREAMING_SNAKE_CASE 		=model.config.eos_token_id

           # use different length sentences to test batching
           SCREAMING_SNAKE_CASE 		=[
               'Hello, my dog is a little',
               'Today, I',
           ]
           SCREAMING_SNAKE_CASE 		=[
               'Hello, my dog is a little over a year old and has been diagnosed with hip dysplasia',
               'Today, I’m going to be talking about a topic that’',
           ]
           return model, tokenizer, sentences, expected_output_sentences
      def 			_lowerCAmelCase	( self	:				List[Any]							):
           # Confirms that we get the expected results with left-padded beam search
           SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE 		=self._get_beam_search_test_objects()

           SCREAMING_SNAKE_CASE 		=tokenizer(snake_case     ,return_tensors='tf'     ,padding=snake_case							)
           SCREAMING_SNAKE_CASE 		=model.generate(**snake_case     ,do_sample=snake_case     ,num_beams=2							)
           SCREAMING_SNAKE_CASE 		=tokenizer.batch_decode(snake_case     ,skip_special_tokens=snake_case							)
           self.assertListEqual(snake_case     ,snake_case							)
      def 			_lowerCAmelCase	( self	:				int							):
           # Confirms that left-padding is working properly
           SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE 		=self._get_beam_search_test_objects()

           SCREAMING_SNAKE_CASE 		=tokenizer(snake_case     ,return_tensors='tf'     ,padding=snake_case							)
           SCREAMING_SNAKE_CASE 		=tokenizer(sentences[0]     ,return_tensors='tf'							)
           SCREAMING_SNAKE_CASE 		=model.generate(**snake_case     ,do_sample=snake_case     ,num_beams=2							)
           SCREAMING_SNAKE_CASE 		=(
               shape_list(inputs_non_padded['input_ids']							)[-1]
               - tf.reduce_sum(tf.cast(inputs['attention_mask'][-1]     ,tf.intaa							)							).numpy()
           )
           SCREAMING_SNAKE_CASE 		=tokenizer(sentences[1]     ,return_tensors='tf'							)
           SCREAMING_SNAKE_CASE 		=model.generate(
               **snake_case     ,do_sample=snake_case     ,num_beams=2     ,max_length=model.config.max_length - num_paddings							)
           SCREAMING_SNAKE_CASE 		=tokenizer.decode(output_non_padded[0]     ,skip_special_tokens=snake_case							)
           SCREAMING_SNAKE_CASE 		=tokenizer.decode(output_padded[0]     ,skip_special_tokens=snake_case							)
           self.assertListEqual(snake_case     ,[non_padded_sentence, padded_sentence]							)


      def 			_lowerCAmelCase	( self	:				Any							):
           # Confirms that XLA is working properly
           SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE		,    SCREAMING_SNAKE_CASE 		=self._get_beam_search_test_objects()

           SCREAMING_SNAKE_CASE 		=tokenizer(snake_case     ,return_tensors='tf'     ,padding=snake_case							)
           SCREAMING_SNAKE_CASE 		=tf.function(model.generate     ,jit_compile=snake_case							)
           SCREAMING_SNAKE_CASE 		=xla_generate(**snake_case     ,do_sample=snake_case     ,num_beams=2							)
           SCREAMING_SNAKE_CASE 		=tokenizer.batch_decode(snake_case     ,skip_special_tokens=snake_case							)
           self.assertListEqual(snake_case     ,snake_case							)




def      snake_case__							(  lowerCAmelCase_,       lowerCAmelCase_     ):





     """simple docstring"""







     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('plaintext must be a string'     )
     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('key must be a string'     )

     if not plaintext:
          raise ValueError('plaintext is empty'     )
     if not key:
          raise ValueError('key is empty'     )

     key += plaintext
     SCREAMING_SNAKE_CASE 		=plaintext.lower()
     SCREAMING_SNAKE_CASE 		=key.lower()
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=''
     while plaintext_iterator < len(lowerCAmelCase_     ):
          if (
              ord(plaintext[plaintext_iterator]     ) < 97
              or ord(plaintext[plaintext_iterator]     ) > 122
          ):
               ciphertext += plaintext[plaintext_iterator]
               plaintext_iterator += 1
          elif ord(key[key_iterator]     ) < 97 or ord(key[key_iterator]     ) > 122:
               key_iterator += 1
          else:
               ciphertext += chr(
                   (
                       (ord(plaintext[plaintext_iterator]     ) - 97 + ord(key[key_iterator]     ))
                       - 97
                   )
                   % 26
                   + 97     )
               key_iterator += 1
               plaintext_iterator += 1
     return ciphertext







def      snake_case__							(  lowerCAmelCase_,       lowerCAmelCase_     ):





     """simple docstring"""







     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('ciphertext must be a string'     )
     if not isinstance(lowerCAmelCase_,       lowerCAmelCase_     ):
          raise TypeError('key must be a string'     )

     if not ciphertext:
          raise ValueError('ciphertext is empty'     )
     if not key:
          raise ValueError('key is empty'     )

     SCREAMING_SNAKE_CASE 		=key.lower()
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=0
     SCREAMING_SNAKE_CASE 		=''
     while ciphertext_iterator < len(lowerCAmelCase_     ):
          if (
              ord(ciphertext[ciphertext_iterator]     ) < 97
              or ord(ciphertext[ciphertext_iterator]     ) > 122
          ):
               plaintext += ciphertext[ciphertext_iterator]
          else:
               plaintext += chr(
                   (ord(ciphertext[ciphertext_iterator]     ) - ord(key[key_iterator]     )) % 26
                   + 97     )
               key += chr(
                   (ord(ciphertext[ciphertext_iterator]     ) - ord(key[key_iterator]     )) % 26
                   + 97     )
               key_iterator += 1
          ciphertext_iterator += 1
     return plaintext


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 _lowerCamelCase							=int(input("Type 1 to encrypt or 2 to decrypt:"))
 if operation == 1:
  _lowerCamelCase							=input("Typeplaintext to be encrypted:\n")
  _lowerCamelCase							=input("Type the key:\n")
  print(encrypt(plaintext, key))
 elif operation == 2:
  _lowerCamelCase							=input("Type the ciphertext to be decrypted:\n")
  _lowerCamelCase							=input("Type the key:\n")
  print(decrypt(ciphertext, key))
 decrypt("jsqqs avvwo", "coffee")

