



import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaConfig, GPTaTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
      import jax
      import jax.numpy as jnp

      from transformers.modeling_flax_pytorch_utils import (
          convert_pytorch_state_dict_to_flax,
          load_flax_weights_in_pytorch_model,
      )
      from transformers.models.gpta.modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel

if is_torch_available():
      import torch

class    _SCREAMING_SNAKE_CASE						:





     def __init__(							self			:				Optional[int]  ,	UpperCamelCase			:				Tuple  ,	UpperCamelCase			:				int=1_4  ,	UpperCamelCase			:				Tuple=7  ,	UpperCamelCase			:				Optional[Any]=True  ,	UpperCamelCase			:				Optional[Any]=True  ,	UpperCamelCase			:				Optional[int]=False  ,	UpperCamelCase			:				str=True  ,	UpperCamelCase			:				Optional[Any]=9_9  ,	UpperCamelCase			:				Optional[int]=3_2  ,	UpperCamelCase			:				List[Any]=5  ,	UpperCamelCase			:				Dict=4  ,	UpperCamelCase			:				List[str]=3_7  ,	UpperCamelCase			:				List[str]="gelu"  ,	UpperCamelCase			:				Optional[Any]=0.1  ,	UpperCamelCase			:				Union[str, Any]=0.1  ,	UpperCamelCase			:				List[str]=5_1_2  ,	UpperCamelCase			:				str=0.0_2  ,	)->str:
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						parent
      __SCREAMING_SNAKE_CASE							:     List[str]							=						batch_size
      __SCREAMING_SNAKE_CASE							:     Dict							=						seq_length
      __SCREAMING_SNAKE_CASE							:     Tuple							=						is_training
      __SCREAMING_SNAKE_CASE							:     int							=						use_input_mask
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						use_token_type_ids
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						use_labels
      __SCREAMING_SNAKE_CASE							:     Dict							=						vocab_size
      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						hidden_size
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						num_hidden_layers
      __SCREAMING_SNAKE_CASE							:     Any							=						num_attention_heads
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						intermediate_size
      __SCREAMING_SNAKE_CASE							:     str							=						hidden_act
      __SCREAMING_SNAKE_CASE							:     int							=						hidden_dropout_prob
      __SCREAMING_SNAKE_CASE							:     str							=						attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE							:     int							=						max_position_embeddings
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						initializer_range
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						None
      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						vocab_size - 1
      __SCREAMING_SNAKE_CASE							:     Dict							=						vocab_size - 1
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						vocab_size - 1





     def 						__snake_case     (							self			:				int					)->str:
      __SCREAMING_SNAKE_CASE							:     List[str]							=						ids_tensor([self.batch_size, self.seq_length]  ,	self.vocab_size					)

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

      __SCREAMING_SNAKE_CASE							:     Dict							=						GPTaConfig(
          vocab_size=self.vocab_size  ,	n_embd=self.hidden_size  ,	n_layer=self.num_hidden_layers  ,	n_head=self.num_attention_heads  ,	n_positions=self.max_position_embeddings  ,	use_cache=UpperCamelCase  ,	bos_token_id=self.bos_token_id  ,	eos_token_id=self.eos_token_id  ,	pad_token_id=self.pad_token_id  ,	)

      return (config, input_ids, input_mask)





     def 						__snake_case     (							self			:				Tuple					)->Optional[Any]:
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						self.prepare_config_and_inputs()
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     Any							=						config_and_inputs
      __SCREAMING_SNAKE_CASE							:     Dict							=						{"input_ids": input_ids, "attention_mask": attention_mask}
      return config, inputs_dict





     def 						__snake_case     (							self			:				Dict					)->Optional[int]:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     List[str]							=						self.prepare_config_and_inputs()

      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						ids_tensor([self.batch_size, self.seq_length]  ,	vocab_size=2					)

      return (
          config,
          input_ids,
          attention_mask,
          encoder_hidden_states,
          encoder_attention_mask,
      )





     def 						__snake_case     (							self			:				List[Any]  ,	UpperCamelCase			:				Optional[Any]  ,	UpperCamelCase			:				List[str]  ,	UpperCamelCase			:				List[str]  ,	UpperCamelCase			:				Tuple					)->Any:
      __SCREAMING_SNAKE_CASE							:     List[str]							=						2_0
      __SCREAMING_SNAKE_CASE							:     str							=						model_class_name(UpperCamelCase					)

      __SCREAMING_SNAKE_CASE							:     Dict							=						model.init_cache(input_ids.shape[0]  ,	UpperCamelCase					)
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						jnp.ones((input_ids.shape[0], max_decoder_length)  ,	dtype="i4"					)

      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						jnp.broadcast_to(
          jnp.arange(input_ids.shape[-1] - 1					)[None, :]  ,	(input_ids.shape[0], input_ids.shape[-1] - 1)					)
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						model(
          input_ids[:, :-1]  ,	attention_mask=UpperCamelCase  ,	past_key_values=UpperCamelCase  ,	position_ids=UpperCamelCase  ,	)

      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]  ,	dtype="i4"					)
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						model(
          input_ids[:, -1:]  ,	attention_mask=UpperCamelCase  ,	past_key_values=outputs_cache.past_key_values  ,	position_ids=UpperCamelCase  ,	)

      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model(UpperCamelCase					)

      __SCREAMING_SNAKE_CASE							:     int							=						np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])					)					)
      self.parent.assertTrue(diff < 1E-3  ,	msg=F"""Max diff is {diff}"""					)






     def 						__snake_case     (							self			:				str  ,	UpperCamelCase			:				str  ,	UpperCamelCase			:				List[Any]  ,	UpperCamelCase			:				Tuple  ,	UpperCamelCase			:				Any					)->Tuple:
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						2_0
      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						model_class_name(UpperCamelCase					)

      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						jnp.concatenate(
          [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])					)]  ,	axis=-1  ,	)

      __SCREAMING_SNAKE_CASE							:     List[str]							=						model.init_cache(input_ids.shape[0]  ,	UpperCamelCase					)
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						jnp.broadcast_to(
          jnp.arange(input_ids.shape[-1] - 1					)[None, :]  ,	(input_ids.shape[0], input_ids.shape[-1] - 1)					)

      __SCREAMING_SNAKE_CASE							:     Dict							=						model(
          input_ids[:, :-1]  ,	attention_mask=UpperCamelCase  ,	past_key_values=UpperCamelCase  ,	position_ids=UpperCamelCase  ,	)
      __SCREAMING_SNAKE_CASE							:     Tuple							=						jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]  ,	dtype="i4"					)
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						model(
          input_ids[:, -1:]  ,	past_key_values=outputs_cache.past_key_values  ,	attention_mask=UpperCamelCase  ,	position_ids=UpperCamelCase  ,	)

      __SCREAMING_SNAKE_CASE							:     List[str]							=						model(UpperCamelCase  ,	attention_mask=UpperCamelCase					)

      __SCREAMING_SNAKE_CASE							:     int							=						np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])					)					)
      self.parent.assertTrue(diff < 1E-3  ,	msg=F"""Max diff is {diff}"""					)






@require_flax
class    _SCREAMING_SNAKE_CASE						(UpperCamelCase      ,     UpperCamelCase      ,     unittest.TestCase			):
     lowerCAmelCase       =      (FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
     lowerCAmelCase       =      (FlaxGPTaLMHeadModel,) if is_flax_available() else ()





     def 						__snake_case     (							self			:				Optional[Any]					)->Tuple:
      __SCREAMING_SNAKE_CASE							:     str							=						FlaxGPTaModelTester(self					)





     def 						__snake_case     (							self			:				List[str]					)->Optional[int]:
      for model_class_name in self.all_model_classes:
       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     str							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.check_use_cache_forward(UpperCamelCase  ,	UpperCamelCase  ,	UpperCamelCase  ,	UpperCamelCase					)





     def 						__snake_case     (							self			:				Optional[Any]					)->str:
      for model_class_name in self.all_model_classes:
       __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     List[Any]							=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.check_use_cache_forward_with_attn_mask(
           UpperCamelCase  ,	UpperCamelCase  ,	UpperCamelCase  ,	UpperCamelCase					)





     @slow
     def 						__snake_case     (							self			:				Any					)->Union[str, Any]:
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						GPTaTokenizer.from_pretrained("gpt2"  ,	pad_token="</s>"  ,	padding_side="left"					)
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						tokenizer(["Hello this is a long string", "Hey"]  ,	return_tensors="np"  ,	padding=UpperCamelCase  ,	truncation=UpperCamelCase					)

      __SCREAMING_SNAKE_CASE							:     Dict							=						FlaxGPTaLMHeadModel.from_pretrained("gpt2"					)
      __SCREAMING_SNAKE_CASE							:     List[str]							=						False
      __SCREAMING_SNAKE_CASE							:     List[str]							=						model.config.eos_token_id

      __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						jax.jit(model.generate					)

      __SCREAMING_SNAKE_CASE							:     int							=						jit_generate(inputs["input_ids"]  ,	attention_mask=inputs["attention_mask"]					).sequences

      __SCREAMING_SNAKE_CASE							:     Optional[int]							=						tokenizer.batch_decode(UpperCamelCase  ,	skip_special_tokens=UpperCamelCase					)

      __SCREAMING_SNAKE_CASE							:     Dict							=						[
          "Hello this is a long string of words. I'm going to start with the first one.\n",
          "Hey, I'm not sure if I'm going to be able to do",
      ]

      self.assertListEqual(UpperCamelCase  ,	UpperCamelCase					)





     @is_pt_flax_cross_test
     def 						__snake_case     (							self			:				Dict					)->Optional[Any]:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     Optional[Any]							=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       with self.subTest(model_class.__name__					):
        # prepare inputs
        __SCREAMING_SNAKE_CASE							:     Tuple							=						self._prepare_for_class(UpperCamelCase  ,	UpperCamelCase					)
        __SCREAMING_SNAKE_CASE							:     Optional[int]							=						{k: torch.tensor(v.tolist()					) for k, v in prepared_inputs_dict.items()}

        # load corresponding PyTorch class
        __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model_class.__name__[4:]  # Skip the "Flax" at the beginning
        __SCREAMING_SNAKE_CASE							:     List[str]							=						getattr(UpperCamelCase  ,	UpperCamelCase					)

        __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     List[Any]							=						pt_inputs["input_ids"].shape
        __SCREAMING_SNAKE_CASE							:     int							=						np.random.randint(0  ,	seq_length - 1  ,	size=(batch_size,)					)
        for batch_idx, start_index in enumerate(UpperCamelCase					):
         __SCREAMING_SNAKE_CASE							:     str							=						0
         __SCREAMING_SNAKE_CASE							:     Dict							=						1
         __SCREAMING_SNAKE_CASE							:     List[str]							=						0
         __SCREAMING_SNAKE_CASE							:     Dict							=						1
        __SCREAMING_SNAKE_CASE							:     Any							=						pt_model_class(UpperCamelCase					).eval()
        __SCREAMING_SNAKE_CASE							:     Optional[int]							=						model_class(UpperCamelCase  ,	dtype=jnp.floataa					)

        __SCREAMING_SNAKE_CASE							:     Optional[int]							=						convert_pytorch_state_dict_to_flax(pt_model.state_dict()  ,	UpperCamelCase					)
        __SCREAMING_SNAKE_CASE							:     int							=						fx_state

        with torch.no_grad():
         __SCREAMING_SNAKE_CASE							:     Optional[int]							=						pt_model(**UpperCamelCase					).to_tuple()

        __SCREAMING_SNAKE_CASE							:     str							=						fx_model(**UpperCamelCase					).to_tuple()
        self.assertEqual(len(UpperCamelCase					)  ,	len(UpperCamelCase					)  ,	"Output lengths differ between Flax and PyTorch"					)
        for fx_output, pt_output in zip(UpperCamelCase  ,	UpperCamelCase					):
         self.assert_almost_equals(fx_output[:, -1]  ,	pt_output[:, -1].numpy()  ,	4E-2					)

        with tempfile.TemporaryDirectory() as tmpdirname:
         pt_model.save_pretrained(UpperCamelCase					)
         __SCREAMING_SNAKE_CASE							:     Tuple							=						model_class.from_pretrained(UpperCamelCase  ,	from_pt=UpperCamelCase					)

        __SCREAMING_SNAKE_CASE							:     Tuple							=						fx_model_loaded(**UpperCamelCase					).to_tuple()
        self.assertEqual(
            len(UpperCamelCase					)  ,	len(UpperCamelCase					)  ,	"Output lengths differ between Flax and PyTorch"					)
        for fx_output_loaded, pt_output in zip(UpperCamelCase  ,	UpperCamelCase					):
         self.assert_almost_equals(fx_output_loaded[:, -1]  ,	pt_output[:, -1].numpy()  ,	4E-2					)





     @is_pt_flax_cross_test
     def 						__snake_case     (							self			:				Dict					)->Tuple:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     Tuple							=						self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes:
       with self.subTest(model_class.__name__					):
        # prepare inputs
        __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						self._prepare_for_class(UpperCamelCase  ,	UpperCamelCase					)
        __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						{k: torch.tensor(v.tolist()					) for k, v in prepared_inputs_dict.items()}

        # load corresponding PyTorch class
        __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model_class.__name__[4:]  # Skip the "Flax" at the beginning
        __SCREAMING_SNAKE_CASE							:     int							=						getattr(UpperCamelCase  ,	UpperCamelCase					)

        __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						pt_model_class(UpperCamelCase					).eval()
        __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						model_class(UpperCamelCase  ,	dtype=jnp.floataa					)

        __SCREAMING_SNAKE_CASE							:     Optional[int]							=						load_flax_weights_in_pytorch_model(UpperCamelCase  ,	fx_model.params					)
        __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     Tuple							=						pt_inputs["input_ids"].shape
        __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						np.random.randint(0  ,	seq_length - 1  ,	size=(batch_size,)					)
        for batch_idx, start_index in enumerate(UpperCamelCase					):
         __SCREAMING_SNAKE_CASE							:     str							=						0
         __SCREAMING_SNAKE_CASE							:     Tuple							=						1
         __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						0
         __SCREAMING_SNAKE_CASE							:     List[Any]							=						1

        # make sure weights are tied in PyTorch
        pt_model.tie_weights()

        with torch.no_grad():
         __SCREAMING_SNAKE_CASE							:     str							=						pt_model(**UpperCamelCase					).to_tuple()

        __SCREAMING_SNAKE_CASE							:     List[str]							=						fx_model(**UpperCamelCase					).to_tuple()
        self.assertEqual(len(UpperCamelCase					)  ,	len(UpperCamelCase					)  ,	"Output lengths differ between Flax and PyTorch"					)
        for fx_output, pt_output in zip(UpperCamelCase  ,	UpperCamelCase					):
         self.assert_almost_equals(fx_output[:, -1]  ,	pt_output[:, -1].numpy()  ,	4E-2					)

        with tempfile.TemporaryDirectory() as tmpdirname:
         fx_model.save_pretrained(UpperCamelCase					)
         __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						pt_model_class.from_pretrained(UpperCamelCase  ,	from_flax=UpperCamelCase					)

        with torch.no_grad():
         __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						pt_model_loaded(**UpperCamelCase					).to_tuple()

        self.assertEqual(
            len(UpperCamelCase					)  ,	len(UpperCamelCase					)  ,	"Output lengths differ between Flax and PyTorch"					)
        for fx_output, pt_output in zip(UpperCamelCase  ,	UpperCamelCase					):
         self.assert_almost_equals(fx_output[:, -1]  ,	pt_output[:, -1].numpy()  ,	4E-2					)






     @slow
     def 						__snake_case     (							self			:				Optional[Any]					)->Dict:
      for model_class_name in self.all_model_classes:
       __SCREAMING_SNAKE_CASE							:     Optional[int]							=						model_class_name.from_pretrained("gpt2"  ,	from_pt=UpperCamelCase					)
       __SCREAMING_SNAKE_CASE							:     str							=						model(np.ones((1, 1)					)					)
       self.assertIsNotNone(UpperCamelCase					)











from __future__ import annotations

from collections import defaultdict
from dataclasses import dataclass



@dataclass
class       _lowercase				:





	"""simple docstring"""
	__A		      =				42
	__A		      =				None
	__A		      =				None






def        a( )						->			TreeNode:
					"""simple docstring"""





					return TreeNode(3					,	TreeNode(9			)					,	TreeNode(20					,	TreeNode(15			)					,	TreeNode(7			)			)			)






def        a( A			:       TreeNode			)						->			list[int]:
					"""simple docstring"""





					def depth_first_search(
					    A			:       TreeNode | None					,	A			:       int					,	A			:       list[int]			) -> None:
										if not root:
															return

										if depth == len(A			):
															right_view.append(root.val			)

										depth_first_search(root.right					,	depth + 1					,	A			)
										depth_first_search(root.left					,	depth + 1					,	A			)

					a   	=  []
					if not root:
										return right_view

					depth_first_search(A					,	0					,	A			)
					return right_view






def        a( A			:       TreeNode			)						->			list[int]:
					"""simple docstring"""





					def depth_first_search(
					    A			:       TreeNode | None					,	A			:       int					,	A			:       list[int]			) -> None:
										if not root:
															return

										if depth == len(A			):
															left_view.append(root.val			)

										depth_first_search(root.left					,	depth + 1					,	A			)
										depth_first_search(root.right					,	depth + 1					,	A			)

					a   	=  []
					if not root:
										return left_view

					depth_first_search(A					,	0					,	A			)
					return left_view






def        a( A			:       TreeNode			)						->			list[int]:
					"""simple docstring"""





					def breadth_first_search(A			:       TreeNode					,	A			:       list[int]			) -> None:
										a   	=  [(root, 0)]
										a   	=  defaultdict(A			)

										while queue:
															a   	=  queue.pop(0			)
															a	,							a   	=  first

															lookup[hd].append(node.val			)

															if node.left:
																				queue.append((node.left, hd - 1)			)
															if node.right:
																				queue.append((node.right, hd + 1)			)

										for pair in sorted(lookup.items()					,	key=lambda A			: each[0]			):
															top_view.append(pair[1][0]			)

					a   	=  []
					if not root:
										return top_view

					breadth_first_search(A					,	A			)
					return top_view






def        a( A			:       TreeNode			)						->			list[int]:
					"""simple docstring"""





					from collections import defaultdict

					def breadth_first_search(A			:       TreeNode					,	A			:       list[int]			) -> None:
										a   	=  [(root, 0)]
										a   	=  defaultdict(A			)

										while queue:
															a   	=  queue.pop(0			)
															a	,							a   	=  first
															lookup[hd].append(node.val			)

															if node.left:
																				queue.append((node.left, hd - 1)			)
															if node.right:
																				queue.append((node.right, hd + 1)			)

										for pair in sorted(lookup.items()					,	key=lambda A			: each[0]			):
															bottom_view.append(pair[1][-1]			)

					a   	=  []
					if not root:
										return bottom_view

					breadth_first_search(A					,	A			)
					return bottom_view


if __name__ == "__main__":
				import doctest

				doctest.testmod()
