
from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers.models.xglm.modeling_tf_xglm import (
				    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFXGLMForCausalLM,
				    TFXGLMModel,
				)




@require_tf
class 		lowercase__    :
	A__       :  int										=XGLMConfig
	A__       :  List[Any]										={}
	A__       :  List[str]										='''gelu'''
	def __init__(     self				:  str			,  UpperCAmelCase_				:  Any			,  UpperCAmelCase_				:  Tuple=14			,  UpperCAmelCase_				:  Optional[Any]=7			,  UpperCAmelCase_				:  str=True			,  UpperCAmelCase_				:  Dict=True			,  UpperCAmelCase_				:  List[Any]=True			,  UpperCAmelCase_				:  List[Any]=99			,  UpperCAmelCase_				:  List[str]=32			,  UpperCAmelCase_				:  Tuple=2			,  UpperCAmelCase_				:  Any=4			,  UpperCAmelCase_				:  List[str]=37			,  UpperCAmelCase_				:  int="gelu"			,  UpperCAmelCase_				:  str=0.1			,  UpperCAmelCase_				:  List[Any]=0.1			,  UpperCAmelCase_				:  Union[str, Any]=512			,  UpperCAmelCase_				:  int=0.02			,  ):
						SCREAMING_SNAKE_CASE__						=					parent
						SCREAMING_SNAKE_CASE__						=					batch_size
						SCREAMING_SNAKE_CASE__						=					seq_length
						SCREAMING_SNAKE_CASE__						=					is_training
						SCREAMING_SNAKE_CASE__						=					use_input_mask
						SCREAMING_SNAKE_CASE__						=					use_labels
						SCREAMING_SNAKE_CASE__						=					vocab_size
						SCREAMING_SNAKE_CASE__						=					d_model
						SCREAMING_SNAKE_CASE__						=					num_hidden_layers
						SCREAMING_SNAKE_CASE__						=					num_attention_heads
						SCREAMING_SNAKE_CASE__						=					ffn_dim
						SCREAMING_SNAKE_CASE__						=					activation_function
						SCREAMING_SNAKE_CASE__						=					activation_dropout
						SCREAMING_SNAKE_CASE__						=					attention_dropout
						SCREAMING_SNAKE_CASE__						=					max_position_embeddings
						SCREAMING_SNAKE_CASE__						=					initializer_range
						SCREAMING_SNAKE_CASE__						=					None
						SCREAMING_SNAKE_CASE__						=					0
						SCREAMING_SNAKE_CASE__						=					2
						SCREAMING_SNAKE_CASE__						=					1
	def 	A_							(     self				:  List[str]				):
						return XGLMConfig.from_pretrained('facebook/xglm-564M'				)
	def 	A_							(     self				:  Optional[Any]				):
						SCREAMING_SNAKE_CASE__						=					tf.clip_by_value(
						    ids_tensor([self.batch_size, self.seq_length]			,  self.vocab_size				)			,  clip_value_min=0			,  clip_value_max=3				)

						SCREAMING_SNAKE_CASE__						=					None
						if self.use_input_mask:
											SCREAMING_SNAKE_CASE__						=					random_attention_mask([self.batch_size, self.seq_length]				)

						SCREAMING_SNAKE_CASE__						=					self.get_config()

						SCREAMING_SNAKE_CASE__						=					floats_tensor([self.num_hidden_layers, self.num_attention_heads]			,  2				)

						return (
						    config,
						    input_ids,
						    input_mask,
						    head_mask,
						)
	def 	A_							(     self				:  List[Any]				):
						return XGLMConfig(
						    vocab_size=self.vocab_size			,  d_model=self.hidden_size			,  num_layers=self.num_hidden_layers			,  attention_heads=self.num_attention_heads			,  ffn_dim=self.ffn_dim			,  activation_function=self.activation_function			,  activation_dropout=self.activation_dropout			,  attention_dropout=self.attention_dropout			,  max_position_embeddings=self.max_position_embeddings			,  initializer_range=self.initializer_range			,  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_dict=UpperCAmelCase_			,  )





	def 	A_							(     self				:  int				):
						SCREAMING_SNAKE_CASE__						=					self.prepare_config_and_inputs()

						(
						    (
						    SCREAMING_SNAKE_CASE__			
						)		,					(
						    SCREAMING_SNAKE_CASE__			
						)		,					(
						    SCREAMING_SNAKE_CASE__			
						)		,					(
						    SCREAMING_SNAKE_CASE__			
						)		,								
						)						=					config_and_inputs

						SCREAMING_SNAKE_CASE__						=					{
						    'input_ids': input_ids,
						    'head_mask': head_mask,
						}

						return config, inputs_dict





@require_tf
class 		lowercase__    (		_UpperCAmelCase	,			_UpperCAmelCase	,			unittest.TestCase    ):
	A__       :  List[Any]										=(TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
	A__       :  Optional[Any]										=(TFXGLMForCausalLM,) if is_tf_available() else ()
	A__       :  Optional[int]										=(
	    {'''feature-extraction''': TFXGLMModel, '''text-generation''': TFXGLMForCausalLM} if is_tf_available() else {}
	)
	A__       :  Dict										=False
	A__       :  Optional[int]										=False
	A__       :  str										=False
	def 	A_							(     self				:  List[Any]				):
						SCREAMING_SNAKE_CASE__						=					TFXGLMModelTester(self				)
						SCREAMING_SNAKE_CASE__						=					ConfigTester(self			,  config_class=UpperCAmelCase_			,  n_embd=37				)
	def 	A_							(     self				:  Dict				):
						self.config_tester.run_common_tests()
	@slow
	def 	A_							(     self				:  Optional[int]				):


						for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											SCREAMING_SNAKE_CASE__						=					TFXGLMModel.from_pretrained(UpperCAmelCase_				)
											self.assertIsNotNone(UpperCAmelCase_				)





	@unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.'				)
	def 	A_							(     self				:  Optional[Any]				):
						super().test_resize_token_embeddings()





@require_tf
class 		lowercase__    (		unittest.TestCase    ):
	@slow
	def 	A_							(     self				:  Any			,  UpperCAmelCase_				:  str=True				):
						SCREAMING_SNAKE_CASE__						=					TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'				)
						SCREAMING_SNAKE_CASE__						=					tf.convert_to_tensor([[2, 268, 9865]]			,  dtype=tf.intaa				)  # The dog
						# </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
						# fmt: off
						SCREAMING_SNAKE_CASE__						=					[2, 268, 9865, 67, 11, 1988, 57252, 9865, 5, 984, 67, 1988, 213838, 1658, 53, 70446, 33, 6657, 278, 1581]
						# fmt: on
						SCREAMING_SNAKE_CASE__						=					model.generate(UpperCAmelCase_			,  do_sample=UpperCAmelCase_			,  num_beams=1				)
						if verify_outputs:
											self.assertListEqual(output_ids[0].numpy().tolist()			,  UpperCAmelCase_				)
	@slow
	def 	A_							(     self				:  Optional[Any]				):
						SCREAMING_SNAKE_CASE__						=					XGLMTokenizer.from_pretrained('facebook/xglm-564M'				)
						SCREAMING_SNAKE_CASE__						=					TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'				)

						tf.random.set_seed(0				)
						SCREAMING_SNAKE_CASE__						=					tokenizer('Today is a nice day and'			,  return_tensors='tf'				)
						SCREAMING_SNAKE_CASE__						=					tokenized.input_ids
						# forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
						with tf.device(':/CPU:0'				):
											SCREAMING_SNAKE_CASE__						=					model.generate(UpperCAmelCase_			,  do_sample=UpperCAmelCase_			,  seed=[7, 0]				)
						SCREAMING_SNAKE_CASE__						=					tokenizer.decode(output_ids[0]			,  skip_special_tokens=UpperCAmelCase_				)

						SCREAMING_SNAKE_CASE__						=					(
						    'Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due'
						)
						self.assertEqual(UpperCAmelCase_			,  UpperCAmelCase_				)





	@slow
	def 	A_							(     self				:  Any				):
						SCREAMING_SNAKE_CASE__						=					TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'				)
						SCREAMING_SNAKE_CASE__						=					XGLMTokenizer.from_pretrained('facebook/xglm-564M'				)

						SCREAMING_SNAKE_CASE__						=					'left'

						# use different length sentences to test batching
						SCREAMING_SNAKE_CASE__						=					[
						    'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
						    'left-padding, such as in batched generation. The output for the sequence below should be the same '
						    'regardless of whether left padding is applied or not. When',
						    'Hello, my dog is a little',
						]

						SCREAMING_SNAKE_CASE__						=					tokenizer(UpperCAmelCase_			,  return_tensors='tf'			,  padding=UpperCAmelCase_				)
						SCREAMING_SNAKE_CASE__						=					inputs['input_ids']

						SCREAMING_SNAKE_CASE__						=					model.generate(input_ids=UpperCAmelCase_			,  attention_mask=inputs['attention_mask']			,  max_new_tokens=12				)

						SCREAMING_SNAKE_CASE__						=					tokenizer(sentences[0]			,  return_tensors='tf'				).input_ids
						SCREAMING_SNAKE_CASE__						=					model.generate(input_ids=UpperCAmelCase_			,  max_new_tokens=12				)

						SCREAMING_SNAKE_CASE__						=					tokenizer(sentences[1]			,  return_tensors='tf'				).input_ids
						SCREAMING_SNAKE_CASE__						=					model.generate(input_ids=UpperCAmelCase_			,  max_new_tokens=12				)

						SCREAMING_SNAKE_CASE__						=					tokenizer.batch_decode(UpperCAmelCase_			,  skip_special_tokens=UpperCAmelCase_				)
						SCREAMING_SNAKE_CASE__						=					tokenizer.decode(output_non_padded[0]			,  skip_special_tokens=UpperCAmelCase_				)
						SCREAMING_SNAKE_CASE__						=					tokenizer.decode(output_padded[0]			,  skip_special_tokens=UpperCAmelCase_				)

						SCREAMING_SNAKE_CASE__						=					[
						    'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
						    'left-padding, such as in batched generation. The output for the sequence below should be the same '
						    'regardless of whether left padding is applied or not. When left padding is applied, the sequence will be '
						    'a single',
						    'Hello, my dog is a little bit of a shy one, but he is very friendly',
						]
						self.assertListEqual(UpperCAmelCase_			,  UpperCAmelCase_				)
						self.assertListEqual(UpperCAmelCase_			,  [non_padded_sentence, padded_sentence]				)











'''simple docstring'''







def 						_A      ( ):






   '''simple docstring'''







   A__       =     [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

   A__       =     6
   A__       =     1
   A__       =     1901

   A__       =     0

   while year < 2001:
      day += 7

      if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
         if day > days_per_month[month - 1] and month != 2:
            month += 1
            A__       =     day - days_per_month[month - 2]
         elif day > 29 and month == 2:
            month += 1
            A__       =     day - 29
      else:
         if day > days_per_month[month - 1]:
            month += 1
            A__       =     day - days_per_month[month - 2]

      if month > 12:
         year += 1
         A__       =     1

      if year < 2001 and day == 1:
         sundays += 1
   return sundays


if __name__ == "__main__":
    print(solution())


