code: 
  
  
  
  
  """simple docstring"""
  
  
  
  import tempfile
  import unittest
  
  import numpy as np
  
  import transformers
  from transformers import GPTaTokenizer, GPTNeoConfig, 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, 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.gpt_neo.modeling_flax_gpt_neo import FlaxGPTNeoForCausalLM, FlaxGPTNeoModel
  
  if is_torch_available():
  						import torch
  
  
  
  
  class 			UpperCAmelCase_						:
  
  
  
  
  				def __init__(					self		: Any			,				snake_case_		: List[str]			,				snake_case_		: List[str]=14			,				snake_case_		: Any=7			,				snake_case_		: str=True			,				snake_case_		: str=True			,				snake_case_		: List[str]=False			,				snake_case_		: int=True			,				snake_case_		: Dict=99			,				snake_case_		: Dict=32			,				snake_case_		: Tuple=4			,				snake_case_		: Union[str, Any]=4			,				snake_case_		: List[str]=[[["global", "local"], 2]]			,				snake_case_		: Dict=37			,				snake_case_		: Dict="gelu"			,				snake_case_		: Dict=0.1			,				snake_case_		: Tuple=0.1			,				snake_case_		: Any=512			,				snake_case_		: int=7			,				snake_case_		: str=0.02			,				)   ->							Any:
  
  
  
  
  					'''simple docstring'''
  
  					A__ =       parent
  					A__ =       batch_size
  					A__ =       seq_length
  					A__ =       is_training
  					A__ =       use_input_mask
  					A__ =       use_token_type_ids
  					A__ =       use_labels
  					A__ =       vocab_size
  					A__ =       hidden_size
  					A__ =       num_hidden_layers
  					A__ =       num_attention_heads
  					A__ =       attention_types
  					A__ =       intermediate_size
  					A__ =       hidden_act
  					A__ =       hidden_dropout_prob
  					A__ =       attention_probs_dropout_prob
  					A__ =       max_position_embeddings
  					A__ =       window_size
  					A__ =       initializer_range
  					A__ =       None
  					A__ =       vocab_size - 1
  					A__ =       vocab_size - 1
  					A__ =       vocab_size - 1
  
  
  
  
  				def 							__magic_name__							(					self		: Tuple   )   ->							Optional[Any]:
  
  
  
  
  					'''simple docstring'''
  
  					A__ =       ids_tensor([self.batch_size, self.seq_length]			,				self.vocab_size   )
  
  					A__ =       None
  					if self.use_input_mask:
  						A__ =       random_attention_mask([self.batch_size, self.seq_length]   )
  
  					A__ =       GPTNeoConfig(
  					    vocab_size=self.vocab_size			,				hidden_size=self.hidden_size			,				num_layers=self.num_hidden_layers			,				num_heads=self.num_attention_heads			,				max_position_embeddings=self.max_position_embeddings			,				use_cache=snake_case_			,				bos_token_id=self.bos_token_id			,				eos_token_id=self.eos_token_id			,				pad_token_id=self.pad_token_id			,				window_size=self.window_size			,				attention_types=self.attention_types			,				)
  
  					return (config, input_ids, input_mask)
  
  
  
  
  				def 							__magic_name__							(					self		: List[Any]   )   ->							Union[str, Any]:
  
  
  
  
  					'''simple docstring'''
  
  					A__ =       self.prepare_config_and_inputs()
  					A__,   A__,   A__ =       config_and_inputs
  					A__ =       {"input_ids": input_ids, "attention_mask": attention_mask}
  					return config, inputs_dict
  
  
  
  
  				def 							__magic_name__							(					self		: Union[str, Any]			,				snake_case_		: int			,				snake_case_		: Union[str, Any]			,				snake_case_		: List[Any]			,				snake_case_		: Union[str, Any]   )   ->							Optional[Any]:
  
  
  
  
  					'''simple docstring'''
  
  					A__ =       20
  					A__ =       model_class_name(snake_case_   )
  
  					A__ =       model.init_cache(input_ids.shape[0]			,				snake_case_   )
  					A__ =       jnp.ones((input_ids.shape[0], max_decoder_length)			,				dtype="i4"   )
  
  					A__ =       jnp.broadcast_to(
  					    jnp.arange(input_ids.shape[-1] - 1   )[None, :]			,				(input_ids.shape[0], input_ids.shape[-1] - 1)   )
  					A__ =       model(
  					    input_ids[:, :-1]			,				attention_mask=snake_case_			,				past_key_values=snake_case_			,				position_ids=snake_case_			,				)
  
  					A__ =       jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]			,				dtype="i4"   )
  					A__ =       model(
  					    input_ids[:, -1:]			,				attention_mask=snake_case_			,				past_key_values=outputs_cache.past_key_values			,				position_ids=snake_case_			,				)
  
  					A__ =       model(snake_case_   )
  
  					A__ =       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 							__magic_name__							(					self		: Tuple			,				snake_case_		: int			,				snake_case_		: List[str]			,				snake_case_		: Tuple			,				snake_case_		: List[str]   )   ->							Optional[int]:
  
  
  
  
  					'''simple docstring'''
  
  					A__ =       20
  					A__ =       model_class_name(snake_case_   )
  
  					A__ =       jnp.concatenate(
  					    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])   )]			,				axis=-1			,				)
  
  					A__ =       model.init_cache(input_ids.shape[0]			,				snake_case_   )
  					A__ =       jnp.broadcast_to(
  					    jnp.arange(input_ids.shape[-1] - 1   )[None, :]			,				(input_ids.shape[0], input_ids.shape[-1] - 1)   )
  
  					A__ =       model(
  					    input_ids[:, :-1]			,				attention_mask=snake_case_			,				past_key_values=snake_case_			,				position_ids=snake_case_			,				)
  					A__ =       jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]			,				dtype="i4"   )
  					A__ =       model(
  					    input_ids[:, -1:]			,				past_key_values=outputs_cache.past_key_values			,				attention_mask=snake_case_			,				position_ids=snake_case_			,				)
  
  					A__ =       model(snake_case_			,				attention_mask=snake_case_   )
  
  					A__ =       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 			UpperCAmelCase_						(		A_,     A_,     unittest.TestCase							):
  				lowercase__		      =   (FlaxGPTNeoModel, FlaxGPTNeoForCausalLM) if is_flax_available() else ()
  				lowercase__		      =   (FlaxGPTNeoForCausalLM,) if is_flax_available() else ()
  
  
  
  
  				def 							__magic_name__							(					self		: str   )   ->							List[Any]:
  
  
  
  
  					'''simple docstring'''
  
  					A__ =       FlaxGPTNeoModelTester(self   )
  
  
  
  
  				def 							__magic_name__							(					self		: Optional[int]   )   ->							Optional[int]:
  
  
  
  
  					'''simple docstring'''
  
  					for model_class_name in self.all_model_classes:
  						A__,   A__,   A__ =       self.model_tester.prepare_config_and_inputs()
  						self.model_tester.check_use_cache_forward(snake_case_			,				snake_case_			,				snake_case_			,				snake_case_   )
  
  
  
  
  				def 							__magic_name__							(					self		: Union[str, Any]   )   ->							List[Any]:
  
  
  
  
  					'''simple docstring'''
  
  					for model_class_name in self.all_model_classes:
  						A__,   A__,   A__ =       self.model_tester.prepare_config_and_inputs()
  						self.model_tester.check_use_cache_forward_with_attn_mask(
  						    snake_case_			,				snake_case_			,				snake_case_			,				snake_case_   )
  
  
  
  
  				@slow
  				def 							__magic_name__							(					self		: Any   )   ->							Union[str, Any]:
  
  
  
  
  					'''simple docstring'''
  
  					A__ =       GPTaTokenizer.from_pretrained("gpt2"			,				pad_token="<|endoftext|>"			,				padding_side="left"   )
  					A__ =       tokenizer(["Hello this is a long string", "Hey"]			,				return_tensors="np"			,				padding=snake_case_			,				truncation=snake_case_   )
  
  					A__ =       FlaxGPTNeoForCausalLM.from_pretrained("EleutherAI/gpt-neo-125M"   )
  					A__ =       False
  					A__ =       model.config.eos_token_id
  
  					A__ =       jax.jit(model.generate   )
  
  					A__ =       jit_generate(
  					    inputs["input_ids"]			,				attention_mask=inputs["attention_mask"]			,				pad_token_id=tokenizer.pad_token_id   ).sequences
  
  					A__ =       tokenizer.batch_decode(snake_case_			,				skip_special_tokens=snake_case_   )
  
  					A__ =       [
  					    "Hello this is a long string of text.\n\nI'm trying to get the text of the",
  					    "Hey, I'm a little late to the party. I'm going to",
  					]
  
  					self.assertListEqual(snake_case_			,				snake_case_   )
  
  
  
  
  				@is_pt_flax_cross_test
  				def 							__magic_name__							(					self		: Dict   )   ->							Any:
  
  
  
  
  					'''simple docstring'''
  
  					A__,   A__ =       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
  							A__ =       self._prepare_for_class(snake_case_			,				snake_case_   )
  							A__ =       {k: torch.tensor(v.tolist()   ) for k, v in prepared_inputs_dict.items()}
  
  							# load corresponding PyTorch class
  							A__ =       model_class.__name__[4:]  # Skip the "Flax" at the beginning
  							A__ =       getattr(snake_case_			,				snake_case_   )
  
  							A__,   A__ =       pt_inputs["input_ids"].shape
  							A__ =       np.random.randint(0			,				seq_length - 1			,				size=(batch_size,)   )
  							for batch_idx, start_index in enumerate(snake_case_   ):
  								A__ =       0
  								A__ =       1
  								A__ =       0
  								A__ =       1
  							A__ =       pt_model_class(snake_case_   ).eval()
  							A__ =       model_class(snake_case_			,				dtype=jnp.floataa   )
  
  							A__ =       convert_pytorch_state_dict_to_flax(pt_model.state_dict()			,				snake_case_   )
  							A__ =       fx_state
  
  							with torch.no_grad():
  								A__ =       pt_model(**snake_case_   ).to_tuple()
  
  							A__ =       fx_model(**snake_case_   ).to_tuple()
  							self.assertEqual(len(snake_case_   )			,				len(snake_case_   )			,				"Output lengths differ between Flax and PyTorch"   )
  							for fx_output, pt_output in zip(snake_case_			,				snake_case_   ):
  								self.assert_almost_equals(fx_output[:, -1]			,				pt_output[:, -1].numpy()			,				4e-2   )
  
  							with tempfile.TemporaryDirectory() as tmpdirname:
  								pt_model.save_pretrained(snake_case_   )
  								A__ =       model_class.from_pretrained(snake_case_			,				from_pt=snake_case_   )
  
  							A__ =       fx_model_loaded(**snake_case_   ).to_tuple()
  							self.assertEqual(
  							    len(snake_case_   )			,				len(snake_case_   )			,				"Output lengths differ between Flax and PyTorch"   )
  							for fx_output_loaded, pt_output in zip(snake_case_			,				snake_case_   ):
  								self.assert_almost_equals(fx_output_loaded[:, -1]			,				pt_output[:, -1].numpy()			,				4e-2   )
  
  
  
  
  				@is_pt_flax_cross_test
  				def 							__magic_name__							(					self		: Optional[Any]   )   ->							Union[str, Any]:
  
  
  
  
  					'''simple docstring'''
  
  					A__,   A__ =       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
  							A__ =       self._prepare_for_class(snake_case_			,				snake_case_   )
  							A__ =       {k: torch.tensor(v.tolist()   ) for k, v in prepared_inputs_dict.items()}
  
  							# load corresponding PyTorch class
  							A__ =       model_class.__name__[4:]  # Skip the "Flax" at the beginning
  							A__ =       getattr(snake_case_			,				snake_case_   )
  
  							A__ =       pt_model_class(snake_case_   ).eval()
  							A__ =       model_class(snake_case_			,				dtype=jnp.floataa   )
  
  							A__ =       load_flax_weights_in_pytorch_model(snake_case_			,				fx_model.params   )
  							A__,   A__ =       pt_inputs["input_ids"].shape
  							A__ =       np.random.randint(0			,				seq_length - 1			,				size=(batch_size,)   )
  							for batch_idx, start_index in enumerate(snake_case_   ):
  								A__ =       0
  								A__ =       1
  								A__ =       0
  								A__ =       1
  
  							# make sure weights are tied in PyTorch
  							pt_model.tie_weights()
  
  							with torch.no_grad():
  								A__ =       pt_model(**snake_case_   ).to_tuple()
  
  							A__ =       fx_model(**snake_case_   ).to_tuple()
  							self.assertEqual(len(snake_case_   )			,				len(snake_case_   )			,				"Output lengths differ between Flax and PyTorch"   )
  							for fx_output, pt_output in zip(snake_case_			,				snake_case_   ):
  								self.assert_almost_equals(fx_output[:, -1]			,				pt_output[:, -1].numpy()			,				4e-2   )
  
  							with tempfile.TemporaryDirectory() as tmpdirname:
  								fx_model.save_pretrained(snake_case_   )
  								A__ =       pt_model_class.from_pretrained(snake_case_			,				from_flax=snake_case_   )
  
  							with torch.no_grad():
  								A__ =       pt_model_loaded(**snake_case_   ).to_tuple()
  
  							self.assertEqual(
  							    len(snake_case_   )			,				len(snake_case_   )			,				"Output lengths differ between Flax and PyTorch"   )
  							for fx_output, pt_output in zip(snake_case_			,				snake_case_   ):
  								self.assert_almost_equals(fx_output[:, -1]			,				pt_output[:, -1].numpy()			,				4e-2   )
  
  
  
  
  				@slow
  				def 							__magic_name__							(					self		: Union[str, Any]   )   ->							Tuple:
  
  
  
  
  					'''simple docstring'''
  
  					for model_class_name in self.all_model_classes:
  						A__ =       model_class_name.from_pretrained("EleutherAI/gpt-neo-125M"   )
  						A__ =       model(np.ones((1, 1)   )   )
  						self.assertIsNotNone(snake_case_   )
  
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  from typing import Optional, Union
  
  from ...file_utils import TensorType
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, TruncationStrategy
  
  
  
  
  class 			UpperCAmelCase_						(		A_							):
      lowercase__		      =   '''MarkupLMFeatureExtractor'''
      lowercase__		      =   ('''MarkupLMTokenizer''', '''MarkupLMTokenizerFast''')
      lowercase__		      =   True
  
  
  
  
      def __call__(					self		: Dict			,				snake_case_		: Optional[int]=None			,				snake_case_		: Union[str, Any]=None			,				snake_case_		: Tuple=None			,				snake_case_		: str=None			,				snake_case_		: Optional[Any]=None			,				snake_case_		: bool = True			,				snake_case_		: Union[bool, str, PaddingStrategy] = False			,				snake_case_		: Union[bool, str, TruncationStrategy] = None			,				snake_case_		: Optional[int] = None			,				snake_case_		: int = 0			,				snake_case_		: Optional[int] = None			,				snake_case_		: Optional[bool] = None			,				snake_case_		: Optional[bool] = None			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = True			,				snake_case_		: Optional[Union[str, TensorType]] = None			,				**snake_case_		: Dict			,				)   ->							BatchEncoding:
  
  
  
  
       '''simple docstring'''
  
       if self.parse_html:
        if html_strings is None:
         raise ValueError("Make sure to pass HTML strings in case `parse_html` is set to `True`"   )
  
        if nodes is not None or xpaths is not None or node_labels is not None:
         raise ValueError(
             "Please don't pass nodes, xpaths nor node labels in case `parse_html` is set to `True`"   )
  
        A__ =       self.feature_extractor(snake_case_   )
        A__ =       features["nodes"]
        A__ =       features["xpaths"]
       else:
        if html_strings is not None:
         raise ValueError("You have passed HTML strings but `parse_html` is set to `False`."   )
        if nodes is None or xpaths is None:
         raise ValueError("Make sure to pass nodes and xpaths in case `parse_html` is set to `False`"   )
  
          # # second, apply the tokenizer
       if questions is not None and self.parse_html:
        if isinstance(snake_case_			,				snake_case_   ):
         A__ =       [questions]  # add batch dimension (as the feature extractor always adds a batch dimension)
  
       A__ =       self.tokenizer(
           text=questions if questions is not None else nodes			,				text_pair=nodes if questions is not None else None			,				xpaths=snake_case_			,				node_labels=snake_case_			,				add_special_tokens=snake_case_			,				padding=snake_case_			,				truncation=snake_case_			,				max_length=snake_case_			,				stride=snake_case_			,				pad_to_multiple_of=snake_case_			,				return_token_type_ids=snake_case_			,				return_attention_mask=snake_case_			,				return_overflowing_tokens=snake_case_			,				return_special_tokens_mask=snake_case_			,				return_offsets_mapping=snake_case_			,				return_length=snake_case_			,				verbose=snake_case_			,				return_tensors=snake_case_			,				**snake_case_			,				)
  
       return encoded_inputs
  
  
  
  
      def 							__magic_name__							(					self		: Optional[Any]			,				*snake_case_		: Any			,				**snake_case_		: Any   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       return self.tokenizer.batch_decode(*snake_case_			,				**snake_case_   )
  
  
  
  
      def 							__magic_name__							(					self		: Tuple			,				*snake_case_		: Optional[Any]			,				**snake_case_		: List[Any]   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       return self.tokenizer.decode(*snake_case_			,				**snake_case_   )
  
  
  
  
      @property
      def 							__magic_name__							(					self		: List[Any]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       self.tokenizer.model_input_names
       return tokenizer_input_names
  
  
  
  
  
  