






"""simple docstring"""





from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import torch

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
@dataclass
class    __lowerCamelCase    (  _a  ):
   a      :				int 						=4_2


try:
  if not (is_transformers_available() and is_torch_available()):
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
  from .pipeline_text_to_video_synth import TextToVideoSDPipeline
  from .pipeline_text_to_video_synth_imgaimg import VideoToVideoSDPipeline  # noqa: F401
  from .pipeline_text_to_video_zero import TextToVideoZeroPipeline












"""simple docstring"""





from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TFConvBertForMaskedLM,
      TFConvBertForMultipleChoice,
      TFConvBertForQuestionAnswering,
      TFConvBertForSequenceClassification,
      TFConvBertForTokenClassification,
      TFConvBertModel,
  )
class    __lowerCamelCase    :

   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_=2 ,				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 ,				)		->       Tuple:
       UpperCamelCase__         =    parent
       UpperCamelCase__         =    13
       UpperCamelCase__         =    7
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True
       UpperCamelCase__         =    99
       UpperCamelCase__         =    384
       UpperCamelCase__         =    2
       UpperCamelCase__         =    4
       UpperCamelCase__         =    37
       UpperCamelCase__         =    'gelu'
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    0.1
       UpperCamelCase__         =    512
       UpperCamelCase__         =    16
       UpperCamelCase__         =    2
       UpperCamelCase__         =    0.02
       UpperCamelCase__         =    3
       UpperCamelCase__         =    4
       UpperCamelCase__         =    128
       UpperCamelCase__         =    2
       UpperCamelCase__         =    9
       UpperCamelCase__         =    1
       UpperCamelCase__         =    None

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size      )

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

       UpperCamelCase__         =    None
       if self.use_token_type_ids:
           UpperCamelCase__         =    ids_tensor([self.batch_size, self.seq_length] ,				self.type_vocab_size      )

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

       UpperCamelCase__         =    ConvBertConfig(
           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 ,				initializer_range=self.initializer_range ,				return_dict=snake_case_ ,				)

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

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertModel(config=snake_case_      )
       UpperCamelCase__         =    {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

       UpperCamelCase__         =    [input_ids, input_mask]
       UpperCamelCase__         =    model(snake_case_      )

       UpperCamelCase__         =    model(snake_case_      )

       self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       int:
       UpperCamelCase__         =    TFConvBertForMaskedLM(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.vocab_size)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForSequenceClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       Tuple:
       UpperCamelCase__         =    self.num_choices
       UpperCamelCase__         =    TFConvBertForMultipleChoice(config=snake_case_      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    tf.tile(tf.expand_dims(snake_case_ ,				1      ) ,				(1, self.num_choices, 1)      )
       UpperCamelCase__         =    {
           'input_ids': multiple_choice_inputs_ids,
           'attention_mask': multiple_choice_input_mask,
           'token_type_ids': multiple_choice_token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_choices)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[str]:
       UpperCamelCase__         =    self.num_labels
       UpperCamelCase__         =    TFConvBertForTokenClassification(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }
       UpperCamelCase__         =    model(snake_case_      )
       self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.seq_length, self.num_labels)      )

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertForQuestionAnswering(config=snake_case_      )
       UpperCamelCase__         =    {
           'input_ids': input_ids,
           'attention_mask': input_mask,
           'token_type_ids': token_type_ids,
       }

       UpperCamelCase__         =    model(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 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    self.prepare_config_and_inputs()
       (
           (
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						(
           UpperCamelCase__
       )       ,						
       )         =    config_and_inputs
       UpperCamelCase__         =    {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
       return config, inputs_dict







@require_tf
class    __lowerCamelCase    (  _a							,	_a							,	unittest.TestCase  ):
   a      :				Any 						=(
       (
           TFConvBertModel,
           TFConvBertForMaskedLM,
           TFConvBertForQuestionAnswering,
           TFConvBertForSequenceClassification,
           TFConvBertForTokenClassification,
           TFConvBertForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   a      :				str 						=(
       {
           """feature-extraction""": TFConvBertModel,
           """fill-mask""": TFConvBertForMaskedLM,
           """question-answering""": TFConvBertForQuestionAnswering,
           """text-classification""": TFConvBertForSequenceClassification,
           """token-classification""": TFConvBertForTokenClassification,
           """zero-shot""": TFConvBertForSequenceClassification,
       }
       if is_tf_available()
       else {}
   )
   a      :				Any 						=False
   a      :				Dict 						=False
   a      :				str 						=False

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    TFConvBertModelTester(self      )
       UpperCamelCase__         =    ConfigTester(self ,				config_class=snake_case_ ,				hidden_size=37      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       self.config_tester.run_common_tests()

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       int:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*snake_case_      )

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    True

       if hasattr(snake_case_ ,				'use_cache'      ):
           UpperCamelCase__         =    True

       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    self._prepare_for_class(snake_case_ ,				snake_case_      )
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    len(model(snake_case_      )      )

           with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_pretrained(snake_case_ ,				saved_model=snake_case_      )
               UpperCamelCase__         =    os.path.join(snake_case_ ,				'saved_model' ,				'1'      )
               UpperCamelCase__         =    tf.keras.models.load_model(snake_case_      )
               UpperCamelCase__         =    model(snake_case_      )

               if self.is_encoder_decoder:
                   UpperCamelCase__         =    outputs['encoder_hidden_states']
                   UpperCamelCase__         =    outputs['encoder_attentions']
               else:
                   UpperCamelCase__         =    outputs['hidden_states']
                   UpperCamelCase__         =    outputs['attentions']

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )

               UpperCamelCase__         =    getattr(
                   self.model_tester ,				'expected_num_hidden_layers' ,				self.model_tester.num_hidden_layers + 1      )

               self.assertEqual(len(snake_case_      ) ,				snake_case_      )
               self.assertListEqual(
                   list(output_hidden_states[0].shape[-2:]      ) ,				[self.model_tester.seq_length, self.model_tester.hidden_size] ,				)

               self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
               self.assertListEqual(
                   list(output_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       self.assertIsNotNone(snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__       ,						UpperCamelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__         =    True
       UpperCamelCase__         =    getattr(self.model_tester ,				'decoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'encoder_seq_length' ,				self.model_tester.seq_length      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )
       UpperCamelCase__         =    getattr(self.model_tester ,				'key_length' ,				snake_case_      )

       def check_decoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(out_len % 2 ,				0      )
           UpperCamelCase__         =    outputs.decoder_attentions
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(decoder_attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length] ,				)

       def check_encoder_attentions_output(snake_case_      ):
           UpperCamelCase__         =    [
               t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
           ]
           self.assertEqual(len(snake_case_      ) ,				self.model_tester.num_hidden_layers      )
           self.assertListEqual(
               list(attentions[0].shape[-3:]      ) ,				[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length] ,				)

       for model_class in self.all_model_classes:
           UpperCamelCase__         =    True
           UpperCamelCase__         =    False
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           UpperCamelCase__         =    len(snake_case_      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           if self.is_encoder_decoder:
               UpperCamelCase__         =    model_class(snake_case_      )
               UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
               self.assertEqual(config.output_hidden_states ,				snake_case_      )
               check_decoder_attentions_output(snake_case_      )

           # Check that output attentions can also be changed via the config
           del inputs_dict["output_attentions"]
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )
           self.assertEqual(config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )

           # Check attention is always last and order is fine
           UpperCamelCase__         =    True
           UpperCamelCase__         =    True
           UpperCamelCase__         =    model_class(snake_case_      )
           UpperCamelCase__         =    model(self._prepare_for_class(snake_case_ ,				snake_case_      )      )

           self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1) ,				len(snake_case_      )      )
           self.assertEqual(model.config.output_hidden_states ,				snake_case_      )
           check_encoder_attentions_output(snake_case_      )







@require_tf
class    __lowerCamelCase    (  unittest.TestCase  ):

   @slow
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    TFConvBertModel.from_pretrained('YituTech/conv-bert-base'      )
       UpperCamelCase__         =    tf.constant([[0, 1, 2, 3, 4, 5]]      )
       UpperCamelCase__         =    model(snake_case_      )[0]

       UpperCamelCase__         =    [1, 6, 768]
       self.assertEqual(output.shape ,				snake_case_      )

       UpperCamelCase__         =    tf.constant(
           [
               [
                   [-0.03_475_493, -0.4_686_034, -0.30_638_832],
                   [0.22_637_248, -0.26_988_646, -0.7_423_424],
                   [0.10_324_868, -0.45_013_508, -0.58_280_784],
               ]
           ]      )
       tf.debugging.assert_near(output[:, :3, :3] ,				snake_case_ ,				atol=1E-4      )




