





import unittest

from diffusers import __version__
from diffusers.utils import deprecate







class     lowerCamelCase(	unittest.TestCase  ):
     '''simple docstring'''


     __magic_name__        = '.'.join([str(int(__version__.split('.'  )[0]  ) + 1  )] + __version__.split('.'  )[1:]  )
     __magic_name__        = '0.0.1'




     def 					lowerCAmelCase__		(						self       ):
         _A    =       {'deprecated_arg': 4}

         with self.assertWarns(snake_case_       ) as warning:
             _A    =       deprecate('deprecated_arg'							,    self.higher_version							,    'message'							,    take_from=snake_case_       )

         assert output == 4
         assert (
             str(warning.warning       )
             == F"The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}."
             " message"
         )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       {'deprecated_arg': 4}

         with self.assertWarns(snake_case_       ) as warning:
             _A    =       deprecate(('deprecated_arg', self.higher_version, 'message')							,    take_from=snake_case_       )

         assert output == 4
         assert (
             str(warning.warning       )
             == F"The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}."
             " message"
         )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       {'deprecated_arg_1': 4, 'deprecated_arg_2': 8}
         with self.assertWarns(snake_case_       ) as warning:
             _A, _A    =       deprecate(
                 ('deprecated_arg_1', self.higher_version, 'Hey')							,    ('deprecated_arg_2', self.higher_version, 'Hey')							,    take_from=snake_case_							,    )
         assert output_a == 4
         assert output_a == 8
         assert (
             str(warning.warnings[0].message       )
             == "The `deprecated_arg_1` argument is deprecated and will be removed in version"
             F" {self.higher_version}. Hey"
         )
         assert (
             str(warning.warnings[1].message       )
             == "The `deprecated_arg_2` argument is deprecated and will be removed in version"
             F" {self.higher_version}. Hey"
         )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       {'deprecated_arg': 4}

         with self.assertRaises(snake_case_       ) as error:
             deprecate(('wrong_arg', self.higher_version, 'message')							,    take_from=snake_case_       )

         assert "test_deprecate_function_incorrect_arg in" in str(error.exception       )
         assert "line" in str(error.exception       )
         assert "got an unexpected keyword argument `deprecated_arg`" in str(error.exception       )




     def 					lowerCAmelCase__		(						self       ):
         with self.assertWarns(snake_case_       ) as warning:
             deprecate(('deprecated_arg', self.higher_version, 'message')       )

         assert (
             str(warning.warning       )
             == F"`deprecated_arg` is deprecated and will be removed in version {self.higher_version}. message"
         )




     def 					lowerCAmelCase__		(						self       ):
         with self.assertWarns(snake_case_       ) as warning:
             deprecate(
                 ('deprecated_arg_1', self.higher_version, 'Hey')							,    ('deprecated_arg_2', self.higher_version, 'Hey')							,    )
         assert (
             str(warning.warnings[0].message       )
             == F"`deprecated_arg_1` is deprecated and will be removed in version {self.higher_version}. Hey"
         )
         assert (
             str(warning.warnings[1].message       )
             == F"`deprecated_arg_2` is deprecated and will be removed in version {self.higher_version}. Hey"
         )




     def 					lowerCAmelCase__		(						self       ):







         class     lowerCamelCase:
              '''simple docstring'''


              __magic_name__        = 5

         with self.assertWarns(snake_case_       ) as warning:
             _A    =       deprecate(('arg', self.higher_version, 'message')							,    take_from=Args()       )

         assert arg == 5
         assert (
             str(warning.warning       )
             == F"The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message"
         )




     def 					lowerCAmelCase__		(						self       ):







         class     lowerCamelCase:
              '''simple docstring'''


              __magic_name__        = 5
              __magic_name__        = 7

         with self.assertWarns(snake_case_       ) as warning:
             _A, _A    =       deprecate(
                 ('arg', self.higher_version, 'message')							,    ('foo', self.higher_version, 'message')							,    ('does not exist', self.higher_version, 'message')							,    take_from=Args()							,    )

         assert arg_a == 5
         assert arg_a == 7
         assert (
             str(warning.warning       )
             == F"The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message"
         )
         assert (
             str(warning.warnings[0].message       )
             == F"The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message"
         )
         assert (
             str(warning.warnings[1].message       )
             == F"The `foo` attribute is deprecated and will be removed in version {self.higher_version}. message"
         )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       {'deprecated_arg': 4}

         with self.assertRaises(snake_case_       ) as error:
             deprecate(('wrong_arg', self.lower_version, 'message')							,    take_from=snake_case_       )

         assert (
             str(error.exception       )
             == "The deprecation tuple ('wrong_arg', '0.0.1', 'message') should be removed since diffusers' version"
             F" {__version__} is >= {self.lower_version}"
         )




     def 					lowerCAmelCase__		(						self       ):
         with self.assertWarns(snake_case_       ) as warning:
             deprecate(('deprecated_arg', self.higher_version, 'This message is better!!!')							,    standard_warn=snake_case_       )

         assert str(warning.warning       ) == "This message is better!!!"




     def 					lowerCAmelCase__		(						self       ):
         with self.assertWarns(snake_case_       ) as warning:
             deprecate(('deprecated_arg', self.higher_version, 'This message is better!!!')							,    standard_warn=snake_case_       )
         assert str(warning.warning       ) == "This message is better!!!"
         assert "diffusers/tests/others/test_utils.py" in warning.filename












import unittest

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

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


if is_torch_available():
 import torch

 from transformers import (
     YosoForMaskedLM,
     YosoForMultipleChoice,
     YosoForQuestionAnswering,
     YosoForSequenceClassification,
     YosoForTokenClassification,
     YosoModel,
 )
 from transformers.models.yoso.modeling_yoso import YOSO_PRETRAINED_MODEL_ARCHIVE_LIST







class     lowerCamelCase:
     '''simple docstring'''


     def __init__(						self							,    snake_case_							,    snake_case_=13							,    snake_case_=7							,    snake_case_=True							,    snake_case_=True							,    snake_case_=True							,    snake_case_=True							,    snake_case_=99							,    snake_case_=32							,    snake_case_=5							,    snake_case_=4							,    snake_case_=37							,    snake_case_="gelu"							,    snake_case_=0.1							,    snake_case_=0.1							,    snake_case_=512							,    snake_case_=16							,    snake_case_=2							,    snake_case_=0.02							,    snake_case_=3							,    snake_case_=4							,    snake_case_=None							,    ):
         _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    =       intermediate_size
         _A    =       hidden_act
         _A    =       hidden_dropout_prob
         _A    =       attention_probs_dropout_prob
         _A    =       max_position_embeddings
         _A    =       type_vocab_size
         _A    =       type_sequence_label_size
         _A    =       initializer_range
         _A    =       num_labels
         _A    =       num_choices
         _A    =       scope




     def 					lowerCAmelCase__		(						self       ):
         _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    =       None
         if self.use_token_type_ids:
             _A    =       ids_tensor([self.batch_size, self.seq_length]							,    self.type_vocab_size       )

         _A    =       None
         _A    =       None
         _A    =       None
         if self.use_labels:
             _A    =       ids_tensor([self.batch_size]							,    self.type_sequence_label_size       )
             _A    =       ids_tensor([self.batch_size, self.seq_length]							,    self.num_labels       )
             _A    =       ids_tensor([self.batch_size]							,    self.num_choices       )

         _A    =       self.get_config()

         return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




     def 					lowerCAmelCase__		(						self       ):
         return YosoConfig(
             vocab_size=self.vocab_size							,    hidden_size=self.hidden_size							,    num_hidden_layers=self.num_hidden_layers							,    num_attention_heads=self.num_attention_heads							,    intermediate_size=self.intermediate_size							,    hidden_act=self.hidden_act							,    hidden_dropout_prob=self.hidden_dropout_prob							,    attention_probs_dropout_prob=self.attention_probs_dropout_prob							,    max_position_embeddings=self.max_position_embeddings							,    type_vocab_size=self.type_vocab_size							,    is_decoder=snake_case_							,    initializer_range=self.initializer_range							,    )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.get_config()
         _A    =       300
         return config




     def 					lowerCAmelCase__		(						self       ):
         (
             (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), 
         )    =       self.prepare_config_and_inputs()

         _A    =       True
         _A    =       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
         _A    =       ids_tensor([self.batch_size, self.seq_length]							,    vocab_size=2       )

         return (
             config,
             input_ids,
             token_type_ids,
             input_mask,
             sequence_labels,
             token_labels,
             choice_labels,
             encoder_hidden_states,
             encoder_attention_mask,
         )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoModel(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_       )
         _A    =       model(snake_case_							,    token_type_ids=snake_case_       )
         _A    =       model(snake_case_       )
         self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    ):
         _A    =       True
         _A    =       YosoModel(snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    encoder_hidden_states=snake_case_							,    encoder_attention_mask=snake_case_							,    )
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    encoder_hidden_states=snake_case_							,    )
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_       )
         self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoForMaskedLM(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    labels=snake_case_       )
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.vocab_size)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       YosoForQuestionAnswering(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    start_positions=snake_case_							,    end_positions=snake_case_							,    )
         self.parent.assertEqual(result.start_logits.shape							,    (self.batch_size, self.seq_length)       )
         self.parent.assertEqual(result.end_logits.shape							,    (self.batch_size, self.seq_length)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_labels
         _A    =       YosoForSequenceClassification(snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    labels=snake_case_       )
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_labels
         _A    =       YosoForTokenClassification(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       model(snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    labels=snake_case_       )
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.seq_length, self.num_labels)       )




     def 					lowerCAmelCase__		(						self							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_							,    snake_case_       ):
         _A    =       self.num_choices
         _A    =       YosoForMultipleChoice(config=snake_case_       )
         model.to(snake_case_       )
         model.eval()
         _A    =       input_ids.unsqueeze(1       ).expand(-1							,    self.num_choices							,    -1       ).contiguous()
         _A    =       token_type_ids.unsqueeze(1       ).expand(-1							,    self.num_choices							,    -1       ).contiguous()
         _A    =       input_mask.unsqueeze(1       ).expand(-1							,    self.num_choices							,    -1       ).contiguous()
         _A    =       model(
             snake_case_							,    attention_mask=snake_case_							,    token_type_ids=snake_case_							,    labels=snake_case_							,    )
         self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_choices)       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.prepare_config_and_inputs()
         (
             (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), (
             _A
         ), 
         )    =       config_and_inputs
         _A    =       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
         return config, inputs_dict







@require_torch
class     lowerCamelCase(	__snake_case ,   __snake_case ,   unittest.TestCase  ):
     '''simple docstring'''


     __magic_name__        = (
         (
             YosoModel,
             YosoForMaskedLM,
             YosoForMultipleChoice,
             YosoForQuestionAnswering,
             YosoForSequenceClassification,
             YosoForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     __magic_name__        = False
     __magic_name__        = False
     __magic_name__        = False

     __magic_name__        = ()
     __magic_name__        = (
         {
             'feature-extraction': YosoModel,
             'fill-mask': YosoForMaskedLM,
             'question-answering': YosoForQuestionAnswering,
             'text-classification': YosoForSequenceClassification,
             'token-classification': YosoForTokenClassification,
             'zero-shot': YosoForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoModelTester(self       )
         _A    =       ConfigTester(self							,    config_class=snake_case_							,    hidden_size=37       )




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




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             _A    =       type
             self.model_tester.create_and_check_model(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_multiple_choice(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         _A    =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*snake_case_       )




     @slow
     def 					lowerCAmelCase__		(						self       ):
         for model_name in YOSO_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _A    =       YosoModel.from_pretrained(snake_case_       )
             self.assertIsNotNone(snake_case_       )




     def 					lowerCAmelCase__		(						self       ):
         return







@require_torch
class     lowerCamelCase(	unittest.TestCase  ):
     '''simple docstring'''


     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoModel.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.tensor([[0, 1, 2, 3, 4, 5]]       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       torch.Size((1, 6, 768)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-0.0611, 0.1242, 0.0840], [0.0280, -0.0048, 0.1125], [0.0106, 0.0226, 0.0751]]]       )

         self.assertTrue(torch.allclose(output[:, :3, :3]							,    snake_case_							,    atol=1E-4       )       )




     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoForMaskedLM.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.tensor([[0, 1, 2, 3, 4, 5]]       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       5_0265

         _A    =       torch.Size((1, 6, vocab_size)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-2.1313, -3.7285, -2.2407], [-2.7047, -3.3314, -2.6408], [0.0629, -2.5166, -0.3356]]]       )

         self.assertTrue(torch.allclose(output[:, :3, :3]							,    snake_case_							,    atol=1E-4       )       )




     @slow
     def 					lowerCAmelCase__		(						self       ):
         _A    =       YosoForMaskedLM.from_pretrained('uw-madison/yoso-4096'       )
         _A    =       torch.arange(4096       ).unsqueeze(0       )

         with torch.no_grad():
             _A    =       model(snake_case_       )[0]

         _A    =       5_0265

         _A    =       torch.Size((1, 4096, vocab_size)       )
         self.assertEqual(output.shape							,    snake_case_       )

         _A    =       torch.tensor(
             [[[-2.3914, -4.3742, -5.0956], [-4.0988, -4.2384, -7.0406], [-3.1427, -3.7192, -6.6800]]]       )

         self.assertTrue(torch.allclose(output[:, :3, :3]							,    snake_case_							,    atol=1E-4       )       )





