

import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


snake_case_        =			1e-4

if is_torch_available():
							import torch

							from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
							from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder


@require_torch
class 				SCREAMING_SNAKE_CASE__ :





				def __init__(				self						,       a						,       a=16						,       a=13						,       a=7						,       a=14						,       a=10						,       a=19						,       a=5						,       a=4						,       a=True						,       a=16						,       a=2						,       a=4						,       a=4						,       a="gelu"						,       a=0.1						,       a=0.1						,       a=[1, 2, 3, 4, 5]						,       a=25						,       a=5						,       ):
									lowercase__   :       List[str]				=	d_model
									lowercase__   :       Union[str, Any]				=	parent
									lowercase__   :       List[Any]				=	batch_size
									lowercase__   :       Optional[int]				=	prediction_length
									lowercase__   :       int				=	context_length
									lowercase__   :       Dict				=	cardinality
									lowercase__   :       Dict				=	num_time_features
									lowercase__   :       Optional[Any]				=	lags_sequence
									lowercase__   :       List[Any]				=	embedding_dimension
									lowercase__   :       int				=	is_training
									lowercase__   :       List[Any]				=	hidden_size
									lowercase__   :       Tuple				=	num_hidden_layers
									lowercase__   :       Dict				=	num_attention_heads
									lowercase__   :       Any				=	intermediate_size
									lowercase__   :       Optional[int]				=	hidden_act
									lowercase__   :       Dict				=	hidden_dropout_prob
									lowercase__   :       int				=	attention_probs_dropout_prob

									lowercase__   :       Any				=	context_length
									lowercase__   :       Tuple				=	prediction_length + label_length
									lowercase__   :       Tuple				=	label_length

									lowercase__   :       Dict				=	moving_average
									lowercase__   :       List[Any]				=	autocorrelation_factor





				def 				snake_case_    (				self):
									return AutoformerConfig(
									    d_model=self.d_model						,       encoder_layers=self.num_hidden_layers						,       decoder_layers=self.num_hidden_layers						,       encoder_attention_heads=self.num_attention_heads						,       decoder_attention_heads=self.num_attention_heads						,       encoder_ffn_dim=self.intermediate_size						,       decoder_ffn_dim=self.intermediate_size						,       dropout=self.hidden_dropout_prob						,       attention_dropout=self.attention_probs_dropout_prob						,       prediction_length=self.prediction_length						,       context_length=self.context_length						,       label_length=self.label_length						,       lags_sequence=self.lags_sequence						,       num_time_features=self.num_time_features						,       num_static_categorical_features=1						,       cardinality=[self.cardinality]						,       embedding_dimension=[self.embedding_dimension]						,       moving_average=self.moving_average						,       )





				def 				snake_case_    (				self						,       a):
									lowercase__   :       List[str]				=	config.context_length + max(config.lags_sequence)

									lowercase__   :       Union[str, Any]				=	ids_tensor([self.batch_size, 1]						,       config.cardinality[0])
									lowercase__   :       List[Any]				=	floats_tensor([self.batch_size, _past_length, config.num_time_features])
									lowercase__   :       int				=	floats_tensor([self.batch_size, _past_length])
									lowercase__   :       Any				=	floats_tensor([self.batch_size, _past_length]) > 0.5

									# decoder inputs
									lowercase__   :       Dict				=	floats_tensor([self.batch_size, config.prediction_length, config.num_time_features])
									lowercase__   :       Dict				=	floats_tensor([self.batch_size, config.prediction_length])

									lowercase__   :       int				=	{
									    'past_values': past_values,
									    'static_categorical_features': static_categorical_features,
									    'past_time_features': past_time_features,
									    'past_observed_mask': past_observed_mask,
									    'future_time_features': future_time_features,
									    'future_values': future_values,
									}
									return inputs_dict





				def 				snake_case_    (				self):
									lowercase__   :       List[Any]				=	self.get_config()
									lowercase__   :       Optional[int]				=	self.prepare_autoformer_inputs_dict(__UpperCAmelCase)
									return config, inputs_dict





				def 				snake_case_    (				self):
									lowercase__				,			lowercase__   :       str				=	self.prepare_config_and_inputs()
									return config, inputs_dict





				def 				snake_case_    (				self						,       a						,       a):
									lowercase__   :       Optional[Any]				=	AutoformerModel(config=__UpperCAmelCase).to(__UpperCAmelCase).eval()
									lowercase__   :       Any				=	model(**__UpperCAmelCase)

									lowercase__   :       Any				=	outputs.encoder_last_hidden_state
									lowercase__   :       List[Any]				=	outputs.last_hidden_state

									with tempfile.TemporaryDirectory() as tmpdirname:
														lowercase__   :       List[str]				=	model.get_encoder()
														encoder.save_pretrained(__UpperCAmelCase)
														lowercase__   :       str				=	AutoformerEncoder.from_pretrained(__UpperCAmelCase).to(__UpperCAmelCase)

									lowercase__				,			lowercase__				,			lowercase__				,			lowercase__				,			lowercase__   :       int				=	model.create_network_inputs(**__UpperCAmelCase)
									lowercase__				,			lowercase__   :       Dict				=	model.decomposition_layer(transformer_inputs[:, : config.context_length, ...])

									lowercase__   :       Optional[int]				=	torch.cat(
									    (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])						,       dim=-1						,       )
									lowercase__   :       List[str]				=	encoder(inputs_embeds=__UpperCAmelCase)[0]
									self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3)

									lowercase__   :       Dict				=	(
									    torch.mean(transformer_inputs[:, : config.context_length, ...]						,       dim=1)
									    .unsqueeze(1)
									    .repeat(1						,       config.prediction_length						,       1)
									)
									lowercase__   :       List[str]				=	torch.zeros(
									    [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]						,       device=enc_input.device						,       )

									lowercase__   :       Dict				=	torch.cat(
									    (
									        torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)						,       dim=1),
									        feature[:, config.context_length - config.label_length :, ...],
									    )						,       dim=-1						,       )
									lowercase__   :       Dict				=	torch.cat(
									    (
									        torch.cat((trend_input[:, -config.label_length :, ...], mean)						,       dim=1),
									        feature[:, config.context_length - config.label_length :, ...],
									    )						,       dim=-1						,       )

									with tempfile.TemporaryDirectory() as tmpdirname:
														lowercase__   :       Union[str, Any]				=	model.get_decoder()
														decoder.save_pretrained(__UpperCAmelCase)
														lowercase__   :       List[str]				=	AutoformerDecoder.from_pretrained(__UpperCAmelCase).to(__UpperCAmelCase)

									lowercase__   :       Optional[int]				=	decoder(
									    trend=__UpperCAmelCase						,       inputs_embeds=__UpperCAmelCase						,       encoder_hidden_states=__UpperCAmelCase						,       )[0]

									self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3)



@require_torch
class 				SCREAMING_SNAKE_CASE__ (__snake_case		,	__snake_case		,	unittest.TestCase					):
				__lowerCamelCase						:	Union[str, Any]														=					(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
				__lowerCamelCase						:	List[Any]														=					(AutoformerForPrediction,) if is_torch_available() else ()
				__lowerCamelCase						:	List[str]														=					{"""feature-extraction""": AutoformerModel} if is_torch_available() else {}
				__lowerCamelCase						:	Tuple														=					False
				__lowerCamelCase						:	Optional[int]														=					False
				__lowerCamelCase						:	Union[str, Any]														=					False
				__lowerCamelCase						:	int														=					False
				__lowerCamelCase						:	Tuple														=					False
				__lowerCamelCase						:	Tuple														=					False





				def 				snake_case_    (				self):
									lowercase__   :       List[Any]				=	AutoformerModelTester(self)
									lowercase__   :       Optional[Any]				=	ConfigTester(self						,       config_class=__UpperCAmelCase						,       has_text_modality=__UpperCAmelCase)





				def 				snake_case_    (				self):
									self.config_tester.run_common_tests()





				def 				snake_case_    (				self):
									lowercase__				,			lowercase__   :       List[Any]				=	self.model_tester.prepare_config_and_inputs()
									for model_class in self.all_model_classes:
														lowercase__   :       Optional[int]				=	model_class(__UpperCAmelCase)

														with tempfile.TemporaryDirectory() as tmpdirname:
																			model.save_pretrained(__UpperCAmelCase)
																			lowercase__				,			lowercase__   :       Optional[int]				=	model_class.from_pretrained(__UpperCAmelCase						,       output_loading_info=__UpperCAmelCase)
														self.assertEqual(info['missing_keys']						,       [])





				def 				snake_case_    (				self):
									lowercase__   :       Any				=	self.model_tester.prepare_config_and_inputs_for_common()
									self.model_tester.check_encoder_decoder_model_standalone(*__UpperCAmelCase)





				@unittest.skip(reason='Model has no tokens embeddings')
				def 				snake_case_    (				self):
									pass





				def 				snake_case_    (				self):
									lowercase__   :       List[Any]				=	inspect.signature(getattr(__UpperCAmelCase						,       'forward'))
									# The main input is the name of the argument after `self`
									lowercase__   :       Optional[int]				=	list(model_signature.parameters.keys())[1]
									self.assertEqual(AutoformerModel.main_input_name						,       __UpperCAmelCase)





				def 				snake_case_    (				self):
									lowercase__				,			lowercase__   :       Tuple				=	self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
														lowercase__   :       List[Any]				=	model_class(__UpperCAmelCase)
														lowercase__   :       Tuple				=	inspect.signature(model.forward)
														# signature.parameters is an OrderedDict => so arg_names order is deterministic
														lowercase__   :       Any				=	[*signature.parameters.keys()]

														lowercase__   :       List[str]				=	[
														    'past_values',
														    'past_time_features',
														    'past_observed_mask',
														    'static_categorical_features',
														    'static_real_features',
														    'future_values',
														    'future_time_features',
														]

														if model.__class__.__name__ in ["AutoformerForPrediction"]:
																			expected_arg_names.append('future_observed_mask')

														expected_arg_names.extend(
														    [
														        'decoder_attention_mask',
														        'head_mask',
														        'decoder_head_mask',
														        'cross_attn_head_mask',
														        'encoder_outputs',
														        'past_key_values',
														        'output_hidden_states',
														        'output_attentions',
														        'use_cache',
														        'return_dict',
														    ])

														self.assertListEqual(arg_names[: len(__UpperCAmelCase)]						,       __UpperCAmelCase)





				def 				snake_case_    (				self):
									lowercase__				,			lowercase__   :       int				=	self.model_tester.prepare_config_and_inputs_for_common()
									lowercase__   :       int				=	True

									lowercase__   :       Union[str, Any]				=	getattr(self.model_tester						,       'seq_length'						,       __UpperCAmelCase)
									lowercase__   :       List[Any]				=	getattr(self.model_tester						,       'decoder_seq_length'						,       __UpperCAmelCase)
									lowercase__   :       Optional[int]				=	getattr(self.model_tester						,       'encoder_seq_length'						,       __UpperCAmelCase)
									lowercase__   :       Union[str, Any]				=	getattr(self.model_tester						,       'd_model'						,       __UpperCAmelCase)
									lowercase__   :       str				=	getattr(self.model_tester						,       'num_attention_heads'						,       __UpperCAmelCase)
									lowercase__   :       Optional[int]				=	d_model // num_attention_heads

									for model_class in self.all_model_classes:
														lowercase__   :       List[Any]				=	True
														lowercase__   :       int				=	False
														lowercase__   :       int				=	True
														lowercase__   :       Optional[int]				=	model_class(__UpperCAmelCase)
														model.to(__UpperCAmelCase)
														model.eval()
														with torch.no_grad():
																			lowercase__   :       Any				=	model(**self._prepare_for_class(__UpperCAmelCase						,       __UpperCAmelCase))
														lowercase__   :       List[Any]				=	outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
														self.assertEqual(len(__UpperCAmelCase)						,       self.model_tester.num_hidden_layers)

														# check that output_attentions also work using config
														del inputs_dict["output_attentions"]
														lowercase__   :       Union[str, Any]				=	True
														lowercase__   :       int				=	model_class(__UpperCAmelCase)
														model.to(__UpperCAmelCase)
														model.eval()
														with torch.no_grad():
																			lowercase__   :       Optional[Any]				=	model(**self._prepare_for_class(__UpperCAmelCase						,       __UpperCAmelCase))
														lowercase__   :       Optional[Any]				=	outputs.encoder_attentions
														self.assertEqual(len(__UpperCAmelCase)						,       self.model_tester.num_hidden_layers)

														self.assertListEqual(
														    list(attentions[0].shape[-3:])						,       [self.model_tester.num_attention_heads, encoder_seq_length, dim]						,       )
														lowercase__   :       Optional[int]				=	len(__UpperCAmelCase)

														lowercase__   :       str				=	7

														if "last_hidden_state" in outputs:
																			correct_outlen += 1

														if "trend" in outputs:
																			correct_outlen += 1

														if "past_key_values" in outputs:
																			correct_outlen += 1  # past_key_values have been returned

														if "loss" in outputs:
																			correct_outlen += 1

														if "params" in outputs:
																			correct_outlen += 1

														self.assertEqual(__UpperCAmelCase						,       __UpperCAmelCase)

														# decoder attentions
														lowercase__   :       List[str]				=	outputs.decoder_attentions
														self.assertIsInstance(__UpperCAmelCase						,       (list, tuple))
														self.assertEqual(len(__UpperCAmelCase)						,       self.model_tester.num_hidden_layers)
														self.assertListEqual(
														    list(decoder_attentions[0].shape[-3:])						,       [self.model_tester.num_attention_heads, decoder_seq_length, dim]						,       )

														# cross attentions
														lowercase__   :       int				=	outputs.cross_attentions
														self.assertIsInstance(__UpperCAmelCase						,       (list, tuple))
														self.assertEqual(len(__UpperCAmelCase)						,       self.model_tester.num_hidden_layers)
														self.assertListEqual(
														    list(cross_attentions[0].shape[-3:])						,       [self.model_tester.num_attention_heads, decoder_seq_length, dim]						,       )

									# Check attention is always last and order is fine
									lowercase__   :       List[Any]				=	True
									lowercase__   :       List[str]				=	True
									lowercase__   :       int				=	model_class(__UpperCAmelCase)
									model.to(__UpperCAmelCase)
									model.eval()
									with torch.no_grad():
														lowercase__   :       Tuple				=	model(**self._prepare_for_class(__UpperCAmelCase						,       __UpperCAmelCase))

									self.assertEqual(out_len + 2						,       len(__UpperCAmelCase))

									lowercase__   :       Union[str, Any]				=	outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

									self.assertEqual(len(__UpperCAmelCase)						,       self.model_tester.num_hidden_layers)
									self.assertListEqual(
									    list(self_attentions[0].shape[-3:])						,       [self.model_tester.num_attention_heads, encoder_seq_length, dim]						,       )





				@is_flaky()
				def 				snake_case_    (				self):
									super().test_retain_grad_hidden_states_attentions()



def      snake_case__      (   SCREAMING_SNAKE_CASE_		:   List[str]="train-batch.pt"      ):



					'''simple docstring'''





					lowercase__   :       Tuple				=	hf_hub_download(repo_id='hf-internal-testing/tourism-monthly-batch'     ,					filename=SCREAMING_SNAKE_CASE_     ,					repo_type='dataset'      )
					lowercase__   :       List[Any]				=	torch.load(SCREAMING_SNAKE_CASE_     ,					map_location=SCREAMING_SNAKE_CASE_      )
					return batch


@require_torch
@slow
class 				SCREAMING_SNAKE_CASE__ (unittest.TestCase					):





				def 				snake_case_    (				self):
									lowercase__   :       int				=	AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly').to(__UpperCAmelCase)
									lowercase__   :       Optional[Any]				=	prepare_batch()

									with torch.no_grad():
														lowercase__   :       Optional[int]				=	model(
														    past_values=batch['past_values']						,       past_time_features=batch['past_time_features']						,       past_observed_mask=batch['past_observed_mask']						,       static_categorical_features=batch['static_categorical_features']						,       future_values=batch['future_values']						,       future_time_features=batch['future_time_features']						,       )[0]

									lowercase__   :       Union[str, Any]				=	torch.Size(
									    (64, model.config.prediction_length + model.config.label_length, model.config.feature_size))
									self.assertEqual(output.shape						,       __UpperCAmelCase)

									lowercase__   :       List[Any]				=	torch.tensor(
									    [[0.3_593, -1.3_398, 0.6_330], [0.2_279, 1.5_396, -0.1_792], [0.0_450, 1.3_225, -0.2_335]]						,       device=__UpperCAmelCase)
									self.assertTrue(torch.allclose(output[0, :3, :3]						,       __UpperCAmelCase						,       atol=__UpperCAmelCase))





				def 				snake_case_    (				self):
									lowercase__   :       Optional[Any]				=	AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly').to(__UpperCAmelCase)
									lowercase__   :       Any				=	prepare_batch('val-batch.pt')
									with torch.no_grad():
														lowercase__   :       Any				=	model(
														    past_values=batch['past_values']						,       past_time_features=batch['past_time_features']						,       past_observed_mask=batch['past_observed_mask']						,       static_categorical_features=batch['static_categorical_features']						,       ).encoder_last_hidden_state
									lowercase__   :       Tuple				=	torch.Size((64, model.config.context_length, model.config.d_model))
									self.assertEqual(output.shape						,       __UpperCAmelCase)

									lowercase__   :       str				=	torch.tensor(
									    [[-0.0_734, -0.9_036, 0.8_358], [4.7_186, 2.4_113, 1.9_581], [1.7_953, 2.3_558, 1.2_970]]						,       device=__UpperCAmelCase)
									self.assertTrue(torch.allclose(output[0, :3, :3]						,       __UpperCAmelCase						,       atol=__UpperCAmelCase))





				def 				snake_case_    (				self):
									lowercase__   :       Union[str, Any]				=	AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly').to(__UpperCAmelCase)
									lowercase__   :       int				=	prepare_batch('val-batch.pt')
									with torch.no_grad():
														lowercase__   :       List[str]				=	model.generate(
														    static_categorical_features=batch['static_categorical_features']						,       past_time_features=batch['past_time_features']						,       past_values=batch['past_values']						,       future_time_features=batch['future_time_features']						,       past_observed_mask=batch['past_observed_mask']						,       )
									lowercase__   :       Dict				=	torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length))
									self.assertEqual(outputs.sequences.shape						,       __UpperCAmelCase)

									lowercase__   :       Any				=	torch.tensor([3_130.6_763, 4_056.5_293, 7_053.0_786]						,       device=__UpperCAmelCase)
									lowercase__   :       Optional[int]				=	outputs.sequences.mean(dim=1)
									self.assertTrue(torch.allclose(mean_prediction[0, -3:]						,       __UpperCAmelCase						,       rtol=1e-1))




from __future__ import annotations


class 				SCREAMING_SNAKE_CASE__ :





    def __init__(				self						,       a						,       a):
         lowercase__				,			lowercase__   :       Dict				=	text, pattern
         lowercase__				,			lowercase__   :       Any				=	len(a), len(a)





    def 				snake_case_    (				self						,       a):

         for i in range(self.patLen - 1						,       -1						,       -1):
              if char == self.pattern[i]:
                   return i
         return -1





    def 				snake_case_    (				self						,       a):

         for i in range(self.patLen - 1						,       -1						,       -1):
              if self.pattern[i] != self.text[current_pos + i]:
                   return current_pos + i
         return -1





    def 				snake_case_    (				self):
         # searches pattern in text and returns index positions
         lowercase__   :       Any				=	[]
         for i in range(self.textLen - self.patLen + 1):
              lowercase__   :       Optional[Any]				=	self.mismatch_in_text(a)
              if mismatch_index == -1:
                   positions.append(a)
              else:
                   lowercase__   :       Optional[int]				=	self.match_in_pattern(self.text[mismatch_index])
                   lowercase__   :       Optional[Any]				=	(
                       mismatch_index - match_index
                   )  # shifting index lgtm [py/multiple-definition]
         return positions



snake_case_        =			'''ABAABA'''
snake_case_        =			'''AB'''
snake_case_        =			BoyerMooreSearch(text, pattern)
snake_case_        =			bms.bad_character_heuristic()

if len(positions) == 0:
       print('''No match found''')
else:
       print('''Pattern found in following positions: ''')
       print(positions)

