




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 		A__				:






	def __init__(	self				,     lowerCamelCase				,     lowerCamelCase=14				,     lowerCamelCase=7				,     lowerCamelCase=True				,     lowerCamelCase=True				,     lowerCamelCase=False				,     lowerCamelCase=True				,     lowerCamelCase=99				,     lowerCamelCase=32				,     lowerCamelCase=5				,     lowerCamelCase=4				,     lowerCamelCase=37				,     lowerCamelCase="gelu"				,     lowerCamelCase=0.1				,     lowerCamelCase=0.1				,     lowerCamelCase=512				,     lowerCamelCase=0.0_2				,     )      ->   Dict:




						"""simple docstring"""






						__magic_name__					:							Tuple		   =							parent
						__magic_name__					:							Union[str, Any]		   =							batch_size
						__magic_name__					:							Any		   =							seq_length
						__magic_name__					:							Tuple		   =							is_training
						__magic_name__					:							Union[str, Any]		   =							use_input_mask
						__magic_name__					:							int		   =							use_token_type_ids
						__magic_name__					:							int		   =							use_labels
						__magic_name__					:							Union[str, Any]		   =							vocab_size
						__magic_name__					:							Tuple		   =							hidden_size
						__magic_name__					:							List[str]		   =							num_hidden_layers
						__magic_name__					:							Tuple		   =							num_attention_heads
						__magic_name__					:							Any		   =							intermediate_size
						__magic_name__					:							str		   =							hidden_act
						__magic_name__					:							int		   =							hidden_dropout_prob
						__magic_name__					:							Optional[Any]		   =							attention_probs_dropout_prob
						__magic_name__					:							List[str]		   =							max_position_embeddings
						__magic_name__					:							List[str]		   =							initializer_range
						__magic_name__					:							int		   =							None
						__magic_name__					:							int		   =							vocab_size - 1
						__magic_name__					:							Any		   =							vocab_size - 1
						__magic_name__					:							List[str]		   =							vocab_size - 1






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						__magic_name__					:							List[Any]		   =							ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size						)

						__magic_name__					:							List[str]		   =							None
						if self.use_input_mask:
											__magic_name__					:							Optional[Any]		   =							random_attention_mask([self.batch_size, self.seq_length]						)

						__magic_name__					:							Optional[Any]		   =							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=snake_case__				,     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  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						__magic_name__					:							List[str]		   =							self.prepare_config_and_inputs()
						__magic_name__					:							Dict		   =							config_and_inputs
						__magic_name__					:							Optional[int]		   =							{"input_ids": input_ids, "attention_mask": attention_mask}
						return config, inputs_dict






	def  lowercase      (	self						)      ->   Dict:




						"""simple docstring"""






						__magic_name__					:							Dict		   =							self.prepare_config_and_inputs()

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

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






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




						"""simple docstring"""






						__magic_name__					:							Any		   =							20
						__magic_name__					:							Dict		   =							model_class_name(snake_case__						)

						__magic_name__					:							Dict		   =							model.init_cache(input_ids.shape[0]				,     snake_case__						)
						__magic_name__					:							List[Any]		   =							jnp.ones((input_ids.shape[0], max_decoder_length)				,     dtype='''i4'''						)

						__magic_name__					:							Optional[int]		   =							jnp.broadcast_to(
						    jnp.arange(input_ids.shape[-1] - 1						)[None, :]				,     (input_ids.shape[0], input_ids.shape[-1] - 1)						)
						__magic_name__					:							int		   =							model(
						    input_ids[:, :-1]				,     attention_mask=snake_case__				,     past_key_values=snake_case__				,     position_ids=snake_case__				,     )

						__magic_name__					:							Any		   =							jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]				,     dtype='''i4'''						)
						__magic_name__					:							Optional[Any]		   =							model(
						    input_ids[:, -1:]				,     attention_mask=snake_case__				,     past_key_values=outputs_cache.past_key_values				,     position_ids=snake_case__				,     )

						__magic_name__					:							int		   =							model(snake_case__						)

						__magic_name__					:							Dict		   =							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  lowercase      (	self				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase				,     lowerCamelCase						)      ->   Any:




						"""simple docstring"""






						__magic_name__					:							List[str]		   =							20
						__magic_name__					:							Tuple		   =							model_class_name(snake_case__						)

						__magic_name__					:							str		   =							jnp.concatenate(
						    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])						)]				,     axis=-1				,     )

						__magic_name__					:							str		   =							model.init_cache(input_ids.shape[0]				,     snake_case__						)
						__magic_name__					:							List[str]		   =							jnp.broadcast_to(
						    jnp.arange(input_ids.shape[-1] - 1						)[None, :]				,     (input_ids.shape[0], input_ids.shape[-1] - 1)						)

						__magic_name__					:							Optional[int]		   =							model(
						    input_ids[:, :-1]				,     attention_mask=snake_case__				,     past_key_values=snake_case__				,     position_ids=snake_case__				,     )
						__magic_name__					:							Optional[int]		   =							jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]				,     dtype='''i4'''						)
						__magic_name__					:							str		   =							model(
						    input_ids[:, -1:]				,     past_key_values=outputs_cache.past_key_values				,     attention_mask=snake_case__				,     position_ids=snake_case__				,     )

						__magic_name__					:							Union[str, Any]		   =							model(snake_case__				,     attention_mask=snake_case__						)

						__magic_name__					:							str		   =							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 		A__				(   SCREAMING_SNAKE_CASE__		,     SCREAMING_SNAKE_CASE__		,     unittest.TestCase ):
	lowerCamelCase__		: Union[str, Any]				    =(FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
	lowerCamelCase__		: Union[str, Any]				    =(FlaxGPTaLMHeadModel,) if is_flax_available() else ()






	def  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						__magic_name__					:							Union[str, Any]		   =							FlaxGPTaModelTester(self						)






	def  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						for model_class_name in self.all_model_classes:
											__magic_name__					:							int		   =							self.model_tester.prepare_config_and_inputs()
											self.model_tester.check_use_cache_forward(snake_case__				,     snake_case__				,     snake_case__				,     snake_case__						)






	def  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						for model_class_name in self.all_model_classes:
											__magic_name__					:							Optional[int]		   =							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  lowercase      (	self						)      ->   str:




						"""simple docstring"""






						__magic_name__					:							Dict		   =							GPTaTokenizer.from_pretrained('''gpt2'''				,     pad_token='''</s>'''				,     padding_side='''left'''						)
						__magic_name__					:							List[str]		   =							tokenizer(['''Hello this is a long string''', '''Hey''']				,     return_tensors='''np'''				,     padding=snake_case__				,     truncation=snake_case__						)

						__magic_name__					:							Union[str, Any]		   =							FlaxGPTaLMHeadModel.from_pretrained('''gpt2'''						)
						__magic_name__					:							int		   =							False
						__magic_name__					:							Tuple		   =							model.config.eos_token_id

						__magic_name__					:							Tuple		   =							jax.jit(model.generate						)

						__magic_name__					:							List[Any]		   =							jit_generate(inputs['''input_ids''']				,     attention_mask=inputs['''attention_mask''']						).sequences

						__magic_name__					:							List[str]		   =							tokenizer.batch_decode(snake_case__				,     skip_special_tokens=snake_case__						)

						__magic_name__					:							Optional[int]		   =							[
						    "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(snake_case__				,     snake_case__						)






	@is_pt_flax_cross_test
	def  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						__magic_name__					:							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
																__magic_name__					:							Dict		   =							self._prepare_for_class(snake_case__				,     snake_case__						)
																__magic_name__					:							Tuple		   =							{k: torch.tensor(v.tolist()						) for k, v in prepared_inputs_dict.items()}

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

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

																__magic_name__					:							List[Any]		   =							convert_pytorch_state_dict_to_flax(pt_model.state_dict()				,     snake_case__						)
																__magic_name__					:							Tuple		   =							fx_state

																with torch.no_grad():
																					__magic_name__					:							Optional[Any]		   =							pt_model(**snake_case__						).to_tuple()

																__magic_name__					:							int		   =							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__						)
																					__magic_name__					:							int		   =							model_class.from_pretrained(snake_case__				,     from_pt=snake_case__						)

																__magic_name__					:							Union[str, Any]		   =							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  lowercase      (	self						)      ->   List[Any]:




						"""simple docstring"""






						__magic_name__					:							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
																__magic_name__					:							Any		   =							self._prepare_for_class(snake_case__				,     snake_case__						)
																__magic_name__					:							Optional[Any]		   =							{k: torch.tensor(v.tolist()						) for k, v in prepared_inputs_dict.items()}

																# load corresponding PyTorch class
																__magic_name__					:							List[Any]		   =							model_class.__name__[4:]  # Skip the "Flax" at the beginning
																__magic_name__					:							Tuple		   =							getattr(snake_case__				,     snake_case__						)

																__magic_name__					:							List[Any]		   =							pt_model_class(snake_case__						).eval()
																__magic_name__					:							int		   =							model_class(snake_case__				,     dtype=jnp.floataa						)

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

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

																with torch.no_grad():
																					__magic_name__					:							Dict		   =							pt_model(**snake_case__						).to_tuple()

																__magic_name__					:							Any		   =							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__						)
																					__magic_name__					:							Tuple		   =							pt_model_class.from_pretrained(snake_case__				,     from_flax=snake_case__						)

																with torch.no_grad():
																					__magic_name__					:							Optional[Any]		   =							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  lowercase      (	self						)      ->   Any:




						"""simple docstring"""






						for model_class_name in self.all_model_classes:
											__magic_name__					:							str		   =							model_class_name.from_pretrained('''gpt2'''				,     from_pt=snake_case__						)
											__magic_name__					:							List[str]		   =							model(np.ones((1, 1)						)						)
											self.assertIsNotNone(snake_case__						)











"""simple docstring"""







import unittest

from transformers import SpeechaTextaConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers.models.speech_to_text_a.modeling_speech_to_text_a import (
			    SpeechaTextaDecoder,
			    SpeechaTextaForCausalLM,
			)


@require_torch
class     __UpperCAmelCase:




						"""simple docstring"""




						def __init__(   self       ,  snake_case__       ,  snake_case__=99       ,  snake_case__=13       ,  snake_case__=16       ,  snake_case__=7       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=False       ,  snake_case__=True       ,  snake_case__=2       ,  snake_case__=32       ,  snake_case__=4       ,  snake_case__=4       ,  snake_case__=30       ,  snake_case__=0       ,  snake_case__=1       ,  snake_case__=2       ,  snake_case__=None       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       parent
												lowercase__				:      Dict=       batch_size
												lowercase__				:      List[str]=       decoder_seq_length
												# For common tests
												lowercase__				:      List[str]=       self.decoder_seq_length
												lowercase__				:      int=       is_training
												lowercase__				:      Any=       use_attention_mask
												lowercase__				:      List[str]=       use_labels

												lowercase__				:      Dict=       vocab_size
												lowercase__				:      Dict=       d_model
												lowercase__				:      Union[str, Any]=       d_model
												lowercase__				:      List[str]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_ffn_dim
												lowercase__				:      Union[str, Any]=       decoder_attention_heads
												lowercase__				:      Tuple=       decoder_attention_heads
												lowercase__				:      Optional[Any]=       eos_token_id
												lowercase__				:      List[Any]=       bos_token_id
												lowercase__				:      Any=       pad_token_id
												lowercase__				:      Union[str, Any]=       decoder_start_token_id
												lowercase__				:      Optional[Any]=       use_cache
												lowercase__				:      List[Any]=       max_position_embeddings

												lowercase__				:      Tuple=       None
												lowercase__				:      Optional[Any]=       decoder_seq_length
												lowercase__				:      Optional[int]=       2
												lowercase__				:      Tuple=       1




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      List[Any]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Tuple=       None
												if self.use_attention_mask:
																		lowercase__				:      List[str]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  vocab_size=2			)

												lowercase__				:      Any=       None
												if self.use_labels:
																		lowercase__				:      str=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Dict=       SpeechaTextaConfig(
												    vocab_size=self.vocab_size       ,  d_model=self.d_model       ,  decoder_layers=self.decoder_layers       ,  decoder_ffn_dim=self.decoder_ffn_dim       ,  decoder_attention_heads=self.decoder_attention_heads       ,  eos_token_id=self.eos_token_id       ,  bos_token_id=self.bos_token_id       ,  use_cache=self.use_cache       ,  pad_token_id=self.pad_token_id       ,  decoder_start_token_id=self.decoder_start_token_id       ,  max_position_embeddings=self.max_position_embeddings       ,  )

												return (
												    config,
												    input_ids,
												    attention_mask,
												    lm_labels,
												)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       True
												lowercase__				:      List[Any]=       SpeechaTextaDecoder(config=snake_case__			).to(snake_case__			).eval()
												lowercase__				:      Any=       input_ids[:2]

												input_ids[input_ids == 0] += 1
												# first forward pass
												lowercase__				:      List[str]=       model(snake_case__       ,  use_cache=snake_case__			)
												lowercase__				:      Optional[Any]=       model(snake_case__			)
												lowercase__				:      List[Any]=       model(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			)

												lowercase__				:      List[Any]=       outputs["past_key_values"]

												# create hypothetical next token and extent to next_input_ids
												lowercase__				:      List[Any]=       ids_tensor((2, 1)       ,  config.vocab_size - 1			) + 1

												# append to next input_ids and
												lowercase__				:      Tuple=       torch.cat([input_ids, next_tokens]       ,  dim=-1			)

												print(snake_case__			)

												lowercase__				:      int=       model(snake_case__			)["last_hidden_state"]
												lowercase__				:      int=       model(snake_case__       ,  past_key_values=snake_case__			)["last_hidden_state"]

												# select random slice
												lowercase__				:      str=       ids_tensor((1,)       ,  output_from_past.shape[-1]			).item()
												lowercase__				:      Any=       output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
												lowercase__				:      int=       output_from_past[:, 0, random_slice_idx].detach()

												# test that outputs are equal for slice
												assert torch.allclose(snake_case__       ,  snake_case__       ,  atol=1e-3			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      str=       self.prepare_config_and_inputs()
												(
												    (
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	
												)				:      Dict=       config_and_inputs

												lowercase__				:      Optional[int]=       {
												    "input_ids": input_ids,
												    "attention_mask": attention_mask,
												}
												return config, inputs_dict


@require_torch
class     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					(SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
						__lowerCamelCase				       =					(SpeechaTextaForCausalLM,) if is_torch_available() else ()
						__lowerCamelCase				       =					{"text-generation": SpeechaTextaForCausalLM} if is_torch_available() else {}
						__lowerCamelCase				       =					True
						__lowerCamelCase				       =					False




						def 		UpperCAmelCase_       (   self       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       SpeechaTextaStandaloneDecoderModelTester(self       ,  is_training=snake_case__			)
												lowercase__				:      int=       ConfigTester(self       ,  config_class=snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												self.config_tester.run_common_tests()




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_decoder_model_past(*snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												return






