



'''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 	UpperCAmelCase	:


 '''simple docstring'''




 def __init__(   self							,  lowerCAmelCase_							,  lowerCAmelCase_=1_3							,  lowerCAmelCase_=7							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=True							,  lowerCAmelCase_=9_9							,  lowerCAmelCase_=3_2							,  lowerCAmelCase_=2							,  lowerCAmelCase_=4							,  lowerCAmelCase_=3_7							,  lowerCAmelCase_="gelu"							,  lowerCAmelCase_=0.1							,  lowerCAmelCase_=0.1							,  lowerCAmelCase_=5_1_2							,  lowerCAmelCase_=1_6							,  lowerCAmelCase_=2							,  lowerCAmelCase_=0.0_2							,  lowerCAmelCase_=3							,  lowerCAmelCase_=4							,  lowerCAmelCase_=None							,  ) ->      Any:



      """simple docstring"""







      a_       		=parent
      a_       		=1_3
      a_       		=7
      a_       		=True
      a_       		=True
      a_       		=True
      a_       		=True
      a_       		=9_9
      a_       		=3_8_4
      a_       		=2
      a_       		=4
      a_       		=3_7
      a_       		="gelu"
      a_       		=0.1
      a_       		=0.1
      a_       		=5_1_2
      a_       		=1_6
      a_       		=2
      a_       		=0.0_2
      a_       		=3
      a_       		=4
      a_       		=1_2_8
      a_       		=2
      a_       		=9
      a_       		=1
      a_       		=None




 def       lowercase_  (   self) ->      int:



      """simple docstring"""







      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_       		=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=A_							,  )

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




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Any:



      """simple docstring"""







      a_       		=TFConvBertModel(config=A_)
      a_       		={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}

      a_       		=[input_ids, input_mask]
      a_       		=model(A_)

      a_       		=model(A_)

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




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[Any]:



      """simple docstring"""







      a_       		=TFConvBertForMaskedLM(config=A_)
      a_       		={
          "input_ids": input_ids,
          "attention_mask": input_mask,
          "token_type_ids": token_type_ids,
      }
      a_       		=model(A_)
      self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.seq_length, self.vocab_size))




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      List[str]:



      """simple docstring"""







      a_       		=self.num_labels
      a_       		=TFConvBertForSequenceClassification(config=A_)
      a_       		={
          "input_ids": input_ids,
          "attention_mask": input_mask,
          "token_type_ids": token_type_ids,
      }

      a_       		=model(A_)
      self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.num_labels))




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[Any]:



      """simple docstring"""







      a_       		=self.num_choices
      a_       		=TFConvBertForMultipleChoice(config=A_)
      a_       		=tf.tile(tf.expand_dims(A_							,  1)							,  (1, self.num_choices, 1))
      a_       		=tf.tile(tf.expand_dims(A_							,  1)							,  (1, self.num_choices, 1))
      a_       		=tf.tile(tf.expand_dims(A_							,  1)							,  (1, self.num_choices, 1))
      a_       		={
          "input_ids": multiple_choice_inputs_ids,
          "attention_mask": multiple_choice_input_mask,
          "token_type_ids": multiple_choice_token_type_ids,
      }
      a_       		=model(A_)
      self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.num_choices))




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Tuple:



      """simple docstring"""







      a_       		=self.num_labels
      a_       		=TFConvBertForTokenClassification(config=A_)
      a_       		={
          "input_ids": input_ids,
          "attention_mask": input_mask,
          "token_type_ids": token_type_ids,
      }
      a_       		=model(A_)
      self.parent.assertEqual(result.logits.shape							,  (self.batch_size, self.seq_length, self.num_labels))




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      Optional[int]:



      """simple docstring"""







      a_       		=TFConvBertForQuestionAnswering(config=A_)
      a_       		={
          "input_ids": input_ids,
          "attention_mask": input_mask,
          "token_type_ids": token_type_ids,
      }

      a_       		=model(A_)
      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       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      a_       		=self.prepare_config_and_inputs()
      (
          a_					
      )       		=config_and_inputs
      a_       		={"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
      return config, inputs_dict







@require_tf
class 	UpperCAmelCase	(		__snake_case					,	__snake_case					,	unittest.TestCase):


 '''simple docstring'''




 __magic_name__					: Dict  =      (
     (
         TFConvBertModel,
         TFConvBertForMaskedLM,
         TFConvBertForQuestionAnswering,
         TFConvBertForSequenceClassification,
         TFConvBertForTokenClassification,
         TFConvBertForMultipleChoice,
     )
     if is_tf_available()
     else ()
 )
 __magic_name__					: Optional[Any]  =      (
     {
         'feature-extraction': TFConvBertModel,
         'fill-mask': TFConvBertForMaskedLM,
         'question-answering': TFConvBertForQuestionAnswering,
         'text-classification': TFConvBertForSequenceClassification,
         'token-classification': TFConvBertForTokenClassification,
         'zero-shot': TFConvBertForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 __magic_name__					: Any  =      False
 __magic_name__					: int  =      False
 __magic_name__					: str  =      False




 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







      a_       		=TFConvBertModelTester(self)
      a_       		=ConfigTester(self							,  config_class=A_							,  hidden_size=3_7)




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







      self.config_tester.run_common_tests()




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*A_)




 def       lowercase_  (   self) ->      Union[str, Any]:



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*A_)




 def       lowercase_  (   self) ->      Optional[int]:



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*A_)




 def       lowercase_  (   self) ->      int:



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*A_)




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



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*A_)




 def       lowercase_  (   self) ->      str:



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*A_)




 @slow
 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs_for_common()
      a_       		=True
      a_       		=True

      if hasattr(A_							,  "use_cache"):
           a_       		=True

      a_       		=getattr(self.model_tester							,  "encoder_seq_length"							,  self.model_tester.seq_length)
      a_       		=getattr(self.model_tester							,  "key_length"							,  A_)

      for model_class in self.all_model_classes:
           a_       		=self._prepare_for_class(A_							,  A_)
           a_       		=model_class(A_)
           a_       		=len(model(A_))

           with tempfile.TemporaryDirectory() as tmpdirname:
                model.save_pretrained(A_							,  saved_model=A_)
                a_       		=os.path.join(A_							,  "saved_model"							,  "1")
                a_       		=tf.keras.models.load_model(A_)
                a_       		=model(A_)

                if self.is_encoder_decoder:
                     a_       		=outputs["encoder_hidden_states"]
                     a_       		=outputs["encoder_attentions"]
                else:
                     a_       		=outputs["hidden_states"]
                     a_       		=outputs["attentions"]

                self.assertEqual(len(A_)							,  A_)

                a_       		=getattr(
                    self.model_tester							,  "expected_num_hidden_layers"							,  self.model_tester.num_hidden_layers + 1)

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

                self.assertEqual(len(A_)							,  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       lowercase_  (   self) ->      str:



      """simple docstring"""







      a_       		=TFConvBertModel.from_pretrained("YituTech/conv-bert-base")
      self.assertIsNotNone(A_)




 def       lowercase_  (   self) ->      Any:



      """simple docstring"""







      a_       		=self.model_tester.prepare_config_and_inputs_for_common()
      a_       		=True
      a_       		=getattr(self.model_tester							,  "decoder_seq_length"							,  self.model_tester.seq_length)
      a_       		=getattr(self.model_tester							,  "encoder_seq_length"							,  self.model_tester.seq_length)
      a_       		=getattr(self.model_tester							,  "key_length"							,  A_)
      a_       		=getattr(self.model_tester							,  "key_length"							,  A_)

      def check_decoder_attentions_output(lowerCAmelCase_):
           a_       		=len(A_)
           self.assertEqual(out_len % 2							,  0)
           a_       		=outputs.decoder_attentions
           self.assertEqual(len(A_)							,  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(lowerCAmelCase_):
           a_       		=[
               t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
           ]
           self.assertEqual(len(A_)							,  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:
           a_       		=True
           a_       		=False
           a_       		=model_class(A_)
           a_       		=model(self._prepare_for_class(A_							,  A_))
           a_       		=len(A_)
           self.assertEqual(config.output_hidden_states							,  A_)
           check_encoder_attentions_output(A_)

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

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

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

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







@require_tf
class 	UpperCAmelCase	(		unittest.TestCase):


 '''simple docstring'''




 @slow
 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







      a_       		=TFConvBertModel.from_pretrained("YituTech/conv-bert-base")
      a_       		=tf.constant([[0, 1, 2, 3, 4, 5]])
      a_       		=model(A_)[0]

      a_       		=[1, 6, 7_6_8]
      self.assertEqual(output.shape							,  A_)

      a_       		=tf.constant(
          [
              [
                  [-0.0_3_4_7_5_4_9_3, -0.4_6_8_6_0_3_4, -0.3_0_6_3_8_8_3_2],
                  [0.2_2_6_3_7_2_4_8, -0.2_6_9_8_8_6_4_6, -0.7_4_2_3_4_2_4],
                  [0.1_0_3_2_4_8_6_8, -0.4_5_0_1_3_5_0_8, -0.5_8_2_8_0_7_8_4],
              ]
          ])
      tf.debugging.assert_near(output[:, :3, :3]							,  A_							,  atol=1e-4)







'''simple docstring'''


from __future__ import annotations

lowercase							       =			[]






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     for i in range(len(lowercase__       )       ):
          if board[row][i] == 1:
               return False
     for i in range(len(lowercase__       )       ):
          if board[i][column] == 1:
               return False
     for i, j in zip(range(lowercase__       ,	-1       ,	-1       )       ,	range(lowercase__       ,	-1       ,	-1       )       ):
          if board[i][j] == 1:
               return False
     for i, j in zip(range(lowercase__       ,	-1       ,	-1       )       ,	range(lowercase__       ,	len(lowercase__       )       )       ):
          if board[i][j] == 1:
               return False
     return True






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     if row >= len(lowercase__       ):
          solution.append(lowercase__       )
          printboard(lowercase__       )
          print()
          return True
     for i in range(len(lowercase__       )       ):
          if is_safe(lowercase__       ,	lowercase__       ,	lowercase__       ):
               a_       		=1
               solve(lowercase__       ,	row + 1       )
               a_       		=0
     return False






def  UpperCAmelCase_       (		lowercase__       ):


     '''simple docstring'''







     for i in range(len(lowercase__       )       ):
          for j in range(len(lowercase__       )       ):
               if board[i][j] == 1:
                    print("Q"       ,	end=" "       )
               else:
                    print("."       ,	end=" "       )
          print()


# n=int(input("The no. of queens"))
lowercase							       =			8
lowercase							       =			[[0 for i in range(n)] for j in range(n)]
solve(board, 0)

print('''The total no. of solutions are :''', len(solution))


