





'''simple docstring'''


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 		UpperCamelCase__     :
      '''simple docstring'''






      def __init__(     self     , SCREAMING_SNAKE_CASE )				->  Dict:
        __lowerCAmelCase		:    str			     =  parent
        __lowerCAmelCase		:    List[Any]			     =  13
        __lowerCAmelCase		:    Optional[int]			     =  7
        __lowerCAmelCase		:    Any			     =  True
        __lowerCAmelCase		:    Union[str, Any]			     =  True
        __lowerCAmelCase		:    Union[str, Any]			     =  True
        __lowerCAmelCase		:    Optional[Any]			     =  True
        __lowerCAmelCase		:    int			     =  True
        __lowerCAmelCase		:    Any			     =  99
        __lowerCAmelCase		:    List[str]			     =  32
        __lowerCAmelCase		:    Tuple			     =  4
        __lowerCAmelCase		:    List[str]			     =  2
        __lowerCAmelCase		:    List[Any]			     =  4
        __lowerCAmelCase		:    Any			     =  37
        __lowerCAmelCase		:    str			     =  'gelu'
        __lowerCAmelCase		:    Optional[Any]			     =  0.1
        __lowerCAmelCase		:    Tuple			     =  0.1
        __lowerCAmelCase		:    List[str]			     =  5_12
        __lowerCAmelCase		:    Any			     =  16
        __lowerCAmelCase		:    Union[str, Any]			     =  2
        __lowerCAmelCase		:    str			     =  0.0_2
        __lowerCAmelCase		:    Optional[Any]			     =  3
        __lowerCAmelCase		:    Dict			     =  4
        __lowerCAmelCase		:    Optional[Any]			     =  None
        __lowerCAmelCase		:    Any			     =  self.vocab_size - 1
        __lowerCAmelCase		:    int			     =  self.vocab_size - 1
        __lowerCAmelCase		:    Dict			     =  self.vocab_size - 1




      def 	snake_case  (     self )				->  Union[str, Any]:
        __lowerCAmelCase		:    Optional[int]			     =  ids_tensor([self.batch_size, self.seq_length]     , self.vocab_size )

        __lowerCAmelCase		:    Dict			     =  None
        if self.use_input_mask:
          __lowerCAmelCase		:    int			     =  random_attention_mask([self.batch_size, self.seq_length] )

        __lowerCAmelCase		:    List[Any]			     =  None
        if self.use_token_type_ids:
          __lowerCAmelCase		:    Union[str, Any]			     =  ids_tensor([self.batch_size, self.seq_length]     , self.type_vocab_size )

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

        __lowerCAmelCase		:    Dict			     =  None
        __lowerCAmelCase		:    Tuple			     =  None
        __lowerCAmelCase		:    List[Any]			     =  None
        if self.use_labels:
          __lowerCAmelCase		:    Dict			     =  ids_tensor([self.batch_size]     , self.type_sequence_label_size )
          __lowerCAmelCase		:    List[str]			     =  ids_tensor([self.batch_size, self.seq_length]     , self.num_labels )
          __lowerCAmelCase		:    List[str]			     =  ids_tensor([self.batch_size]     , self.num_choices )

        __lowerCAmelCase		:    List[Any]			     =  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=SCREAMING_SNAKE_CASE     , )

        __lowerCAmelCase		:    Union[str, Any]			     =  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 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , *SCREAMING_SNAKE_CASE )				->  Union[str, Any]:
        __lowerCAmelCase		:    Any			     =  TFGPTJModel(config=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    List[str]			     =  {
            'input_ids': input_ids,
            'attention_mask': input_mask,
            'token_type_ids': token_type_ids,
        }
        __lowerCAmelCase		:    List[Any]			     =  model(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Tuple			     =  [input_ids, None, input_mask]  # None is the input for 'past'
        __lowerCAmelCase		:    int			     =  model(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Union[str, Any]			     =  model(SCREAMING_SNAKE_CASE )

        self.parent.assertEqual(result.last_hidden_state.shape     , (self.batch_size, self.seq_length, self.hidden_size) )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , *SCREAMING_SNAKE_CASE )				->  int:
        __lowerCAmelCase		:    List[Any]			     =  TFGPTJModel(config=SCREAMING_SNAKE_CASE )

        # first forward pass
        __lowerCAmelCase		:    Tuple			     =  model(SCREAMING_SNAKE_CASE     , token_type_ids=SCREAMING_SNAKE_CASE     , use_cache=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    str			     =  model(SCREAMING_SNAKE_CASE     , token_type_ids=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Optional[int]			     =  model(SCREAMING_SNAKE_CASE     , token_type_ids=SCREAMING_SNAKE_CASE     , use_cache=SCREAMING_SNAKE_CASE )

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

        __lowerCAmelCase     ,					__lowerCAmelCase		:    Tuple			     =  outputs.to_tuple()

        # create hypothetical next token and extent to next_input_ids
        __lowerCAmelCase		:    List[str]			     =  ids_tensor((self.batch_size, 1)     , config.vocab_size )
        __lowerCAmelCase		:    int			     =  ids_tensor([self.batch_size, 1]     , self.type_vocab_size )

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

        __lowerCAmelCase		:    int			     =  model(SCREAMING_SNAKE_CASE     , token_type_ids=SCREAMING_SNAKE_CASE )['last_hidden_state']
        __lowerCAmelCase		:    Union[str, Any]			     =  model(SCREAMING_SNAKE_CASE     , token_type_ids=SCREAMING_SNAKE_CASE     , past_key_values=SCREAMING_SNAKE_CASE )[
            'last_hidden_state'
        ]

        # select random slice
        __lowerCAmelCase		:    List[str]			     =  int(ids_tensor((1,)     , shape_list(SCREAMING_SNAKE_CASE )[-1] ) )
        __lowerCAmelCase		:    int			     =  output_from_no_past[:, -1, random_slice_idx]
        __lowerCAmelCase		:    Optional[Any]			     =  output_from_past[:, 0, random_slice_idx]

        # test that outputs are equal for slice
        tf.debugging.assert_near(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , rtol=1e-6 )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , *SCREAMING_SNAKE_CASE )				->  Optional[Any]:
        __lowerCAmelCase		:    Dict			     =  TFGPTJModel(config=SCREAMING_SNAKE_CASE )

        # create attention mask
        __lowerCAmelCase		:    Any			     =  self.seq_length // 2
        __lowerCAmelCase		:    Dict			     =  tf.ones((self.batch_size, half_seq_length)     , dtype=tf.intaa )
        __lowerCAmelCase		:    Union[str, Any]			     =  tf.zeros((self.batch_size, self.seq_length - half_seq_length)     , dtype=tf.intaa )
        __lowerCAmelCase		:    Optional[Any]			     =  tf.concat([attn_mask_begin, attn_mask_end]     , axis=1 )

        # first forward pass
        __lowerCAmelCase     ,					__lowerCAmelCase		:    int			     =  model(SCREAMING_SNAKE_CASE     , attention_mask=SCREAMING_SNAKE_CASE ).to_tuple()

        # create hypothetical next token and extent to next_input_ids
        __lowerCAmelCase		:    Optional[int]			     =  ids_tensor((self.batch_size, 1)     , config.vocab_size )

        # change a random masked slice from input_ids
        __lowerCAmelCase		:    str			     =  ids_tensor((1,)     , SCREAMING_SNAKE_CASE ).numpy() + 1
        __lowerCAmelCase		:    List[Any]			     =  ids_tensor((self.batch_size, self.seq_length)     , config.vocab_size )
        __lowerCAmelCase		:    Optional[int]			     =  tf.range(self.seq_length ) == (self.seq_length - random_seq_idx_to_change)
        __lowerCAmelCase		:    int			     =  tf.transpose(
            tf.broadcast_to(tf.expand_dims(SCREAMING_SNAKE_CASE     , -1 )     , (self.seq_length, self.batch_size) ) )
        __lowerCAmelCase		:    Optional[int]			     =  tf.where(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )

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

        # get two different outputs
        __lowerCAmelCase		:    Optional[int]			     =  model(SCREAMING_SNAKE_CASE     , attention_mask=SCREAMING_SNAKE_CASE )['last_hidden_state']
        __lowerCAmelCase		:    List[Any]			     =  model(SCREAMING_SNAKE_CASE     , past_key_values=SCREAMING_SNAKE_CASE     , attention_mask=SCREAMING_SNAKE_CASE )[
            'last_hidden_state'
        ]

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

        # test that outputs are equal for slice
        tf.debugging.assert_near(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , rtol=1e-12 )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , *SCREAMING_SNAKE_CASE )				->  Tuple:
        __lowerCAmelCase		:    Dict			     =  TFGPTJModel(config=SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    str			     =  input_ids[:1, :]
        __lowerCAmelCase		:    Dict			     =  input_mask[:1, :]
        __lowerCAmelCase		:    Optional[Any]			     =  token_type_ids[:1, :]
        __lowerCAmelCase		:    Dict			     =  1

        # first forward pass
        __lowerCAmelCase		:    Optional[int]			     =  model(SCREAMING_SNAKE_CASE     , attention_mask=SCREAMING_SNAKE_CASE     , token_type_ids=SCREAMING_SNAKE_CASE     , use_cache=SCREAMING_SNAKE_CASE )

        __lowerCAmelCase     ,					__lowerCAmelCase		:    Dict			     =  outputs.to_tuple()

        # create hypothetical next token and extent to next_input_ids
        __lowerCAmelCase		:    Dict			     =  ids_tensor((self.batch_size, 3)     , config.vocab_size )
        __lowerCAmelCase		:    str			     =  ids_tensor((self.batch_size, 3)     , 2 )
        __lowerCAmelCase		:    int			     =  ids_tensor((self.batch_size, 3)     , self.type_vocab_size )

        # append to next input_ids and token_type_ids
        __lowerCAmelCase		:    Optional[Any]			     =  tf.concat([input_ids, next_tokens]     , axis=-1 )
        __lowerCAmelCase		:    Optional[Any]			     =  tf.concat([input_mask, next_attn_mask]     , axis=-1 )
        __lowerCAmelCase		:    int			     =  tf.concat([token_type_ids, next_token_types]     , axis=-1 )

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

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

        # test that outputs are equal for slice
        tf.debugging.assert_near(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , rtol=1e-3 )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , *SCREAMING_SNAKE_CASE )				->  List[Any]:
        __lowerCAmelCase		:    List[Any]			     =  TFGPTJForCausalLM(config=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    List[Any]			     =  {
            'input_ids': input_ids,
            'attention_mask': input_mask,
            'token_type_ids': token_type_ids,
        }
        __lowerCAmelCase		:    int			     =  model(SCREAMING_SNAKE_CASE )
        self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.seq_length, self.vocab_size) )







      def 	snake_case  (     self )				->  str:
        __lowerCAmelCase		:    Optional[Any]			     =  self.prepare_config_and_inputs()

        (
            (
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					(
            __lowerCAmelCase
        )     ,					
        )		:    Tuple			     =  config_and_inputs

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



@require_tf
class 		UpperCamelCase__     (       a	,	a	,	a	,	unittest.TestCase							):
      '''simple docstring'''






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

      _snake_case           =				(TFGPTJForCausalLM,) if is_tf_available() else ()
      _snake_case           =				(
          {
              '''feature-extraction''': TFGPTJModel,
              '''question-answering''': TFGPTJForQuestionAnswering,
              '''text-classification''': TFGPTJForSequenceClassification,
              '''text-generation''': TFGPTJForCausalLM,
              '''zero-shot''': TFGPTJForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  List[Any]:
        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 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase		:    List[Any]			     =  TFGPTJModelTester(self )
        __lowerCAmelCase		:    Tuple			     =  ConfigTester(self     , config_class=SCREAMING_SNAKE_CASE     , n_embd=37 )




      def 	snake_case  (     self )				->  Tuple:
        self.config_tester.run_common_tests()




      def 	snake_case  (     self )				->  str:
        __lowerCAmelCase		:    Union[str, Any]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_gptj_model(*SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase		:    Dict			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_gptj_model_past(*SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Any:
        __lowerCAmelCase		:    int			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_gptj_model_attention_mask_past(*SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  int:
        __lowerCAmelCase		:    Optional[int]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_gptj_model_past_large_inputs(*SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  List[Any]:
        __lowerCAmelCase		:    int			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_gptj_lm_head_model(*SCREAMING_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 	snake_case  (     self )				->  Any:
        __lowerCAmelCase		:    Optional[int]			     =  TFGPTJModel.from_pretrained('EleutherAI/gpt-j-6B'     , from_pt=SCREAMING_SNAKE_CASE )
        self.assertIsNotNone(SCREAMING_SNAKE_CASE )







      @unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.' )
      def 	snake_case  (     self )				->  Dict:
        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 		UpperCamelCase__     (       unittest.TestCase							):
      '''simple docstring'''






      def 	snake_case  (     self )				->  Union[str, Any]:
        __lowerCAmelCase		:    Optional[int]			     =  TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'     , from_pt=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Tuple			     =  tf.convert_to_tensor([[4_64, 32_90]]     , 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
        __lowerCAmelCase		:    Optional[int]			     =  [4_64, 32_90, 3_18, 2_57, 5_82, 3_38, 12_66, 15_45, 13, 6_32, 3_18, 2_57, 91_12, 1_51_85, 11, 2_90, 3_40, 3_18, 2_57, 15_45]
        # fmt: on
        __lowerCAmelCase		:    str			     =  model.generate(SCREAMING_SNAKE_CASE     , do_sample=SCREAMING_SNAKE_CASE )
        self.assertListEqual(output_ids[0].numpy().tolist()     , SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  List[Any]:
        __lowerCAmelCase		:    str			     =  AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'     , revision='float16' )
        __lowerCAmelCase		:    Dict			     =  TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'     , revision='float16'     , from_pt=SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Optional[int]			     =  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' ):
          __lowerCAmelCase		:    List[str]			     =  model.generate(**SCREAMING_SNAKE_CASE     , do_sample=SCREAMING_SNAKE_CASE     , seed=[42, 0] )
        __lowerCAmelCase		:    Dict			     =  tokenizer.decode(output_ids[0]     , skip_special_tokens=SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    str			     =  'Today is a nice day and I’m going to go for a walk. I’'
        self.assertEqual(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  List[str]:
        __lowerCAmelCase		:    List[Any]			     =  TFGPTJForCausalLM.from_pretrained('EleutherAI/gpt-j-6B'     , revision='float16'     , from_pt=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Union[str, Any]			     =  AutoTokenizer.from_pretrained('EleutherAI/gpt-j-6B'     , revision='float16' )

        __lowerCAmelCase		:    List[Any]			     =  'left'

        # Define PAD Token = EOS Token = 50256
        __lowerCAmelCase		:    List[str]			     =  tokenizer.eos_token
        __lowerCAmelCase		:    List[Any]			     =  model.config.eos_token_id

        # use different length sentences to test batching
        __lowerCAmelCase		:    Union[str, Any]			     =  [
            'Hello, my dog is a little',
            'Today, I',
        ]
        __lowerCAmelCase		:    Any			     =  [
            '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 	snake_case  (     self )				->  str:
        # Confirms that we get the expected results with left-padded beam search
        __lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase		:    Optional[int]			     =  self._get_beam_search_test_objects()

        __lowerCAmelCase		:    List[str]			     =  tokenizer(SCREAMING_SNAKE_CASE     , return_tensors='tf'     , padding=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Any			     =  model.generate(**SCREAMING_SNAKE_CASE     , do_sample=SCREAMING_SNAKE_CASE     , num_beams=2 )
        __lowerCAmelCase		:    Any			     =  tokenizer.batch_decode(SCREAMING_SNAKE_CASE     , skip_special_tokens=SCREAMING_SNAKE_CASE )
        self.assertListEqual(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[int]:
        # Confirms that left-padding is working properly
        __lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase		:    str			     =  self._get_beam_search_test_objects()

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







      def 	snake_case  (     self )				->  Tuple:
        # Confirms that XLA is working properly
        __lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase		:    Any			     =  self._get_beam_search_test_objects()

        __lowerCAmelCase		:    List[Any]			     =  tokenizer(SCREAMING_SNAKE_CASE     , return_tensors='tf'     , padding=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Union[str, Any]			     =  tf.function(model.generate     , jit_compile=SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Tuple			     =  xla_generate(**SCREAMING_SNAKE_CASE     , do_sample=SCREAMING_SNAKE_CASE     , num_beams=2 )
        __lowerCAmelCase		:    Tuple			     =  tokenizer.batch_decode(SCREAMING_SNAKE_CASE     , skip_special_tokens=SCREAMING_SNAKE_CASE )
        self.assertListEqual(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )












'''simple docstring'''


from __future__ import annotations




def       A							(      _UpperCAmelCase   :				list[int]						,_UpperCAmelCase   :				int					)  ->				int:


  '''simple docstring'''




  __lowerCAmelCase     ,					__lowerCAmelCase		:    Dict			     =  0, len(_UpperCAmelCase					) - 1
  while start_ind <= end_ind:
    if array[start_ind] == search_item:
      return start_ind
    elif array[end_ind] == search_item:
      return end_ind
    else:
      start_ind += 1
      end_ind -= 1
    # returns -1 if search_item is not found in array
  return -1


if __name__ == "__main__":
    print(double_linear_search(list(range(1_00)), 40))





