






from __future__ import annotations

import unittest

from transformers import 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 numpy
		import tensorflow as tf

		from transformers import (
		    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    BertConfig,
		    DPRConfig,
		    TFDPRContextEncoder,
		    TFDPRQuestionEncoder,
		    TFDPRReader,
		)





class __lowerCamelCase :





	"""simple docstring"""






	def __init__(							self       ,    UpperCAmelCase       ,    UpperCAmelCase=13       ,    UpperCAmelCase=7       ,    UpperCAmelCase=True       ,    UpperCAmelCase=True       ,    UpperCAmelCase=True       ,    UpperCAmelCase=True       ,    UpperCAmelCase=99       ,    UpperCAmelCase=32       ,    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=None       ,    UpperCAmelCase=0       ,    ):
							"""simple docstring"""







							_UpperCAmelCase									=			parent
							_UpperCAmelCase									=			batch_size
							_UpperCAmelCase									=			seq_length
							_UpperCAmelCase									=			is_training
							_UpperCAmelCase									=			use_input_mask
							_UpperCAmelCase									=			use_token_type_ids
							_UpperCAmelCase									=			use_labels
							_UpperCAmelCase									=			vocab_size
							_UpperCAmelCase									=			hidden_size
							_UpperCAmelCase									=			num_hidden_layers
							_UpperCAmelCase									=			num_attention_heads
							_UpperCAmelCase									=			intermediate_size
							_UpperCAmelCase									=			hidden_act
							_UpperCAmelCase									=			hidden_dropout_prob
							_UpperCAmelCase									=			attention_probs_dropout_prob
							_UpperCAmelCase									=			max_position_embeddings
							_UpperCAmelCase									=			type_vocab_size
							_UpperCAmelCase									=			type_sequence_label_size
							_UpperCAmelCase									=			initializer_range
							_UpperCAmelCase									=			num_labels
							_UpperCAmelCase									=			num_choices
							_UpperCAmelCase									=			scope
							_UpperCAmelCase									=			projection_dim

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			ids_tensor([self.batch_size, self.seq_length]       ,    self.vocab_size    )

							_UpperCAmelCase									=			None
							if self.use_input_mask:
													# follow test_modeling_tf_ctrl.py
													_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									=			BertConfig(
							    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=UpperCAmelCase       ,    initializer_range=self.initializer_range       ,    )
							_UpperCAmelCase									=			DPRConfig(projection_dim=self.projection_dim       ,    **config.to_dict()    )

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

	def        UpperCamelCase    (							self       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			TFDPRContextEncoder(config=UpperCAmelCase    )
							_UpperCAmelCase									=			model(UpperCAmelCase       ,    attention_mask=UpperCAmelCase       ,    token_type_ids=UpperCAmelCase    )
							_UpperCAmelCase									=			model(UpperCAmelCase       ,    token_type_ids=UpperCAmelCase    )
							_UpperCAmelCase									=			model(UpperCAmelCase    )
							self.parent.assertEqual(result.pooler_output.shape       ,    (self.batch_size, self.projection_dim or self.hidden_size)    )

	def        UpperCamelCase    (							self       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			TFDPRQuestionEncoder(config=UpperCAmelCase    )
							_UpperCAmelCase									=			model(UpperCAmelCase       ,    attention_mask=UpperCAmelCase       ,    token_type_ids=UpperCAmelCase    )
							_UpperCAmelCase									=			model(UpperCAmelCase       ,    token_type_ids=UpperCAmelCase    )
							_UpperCAmelCase									=			model(UpperCAmelCase    )
							self.parent.assertEqual(result.pooler_output.shape       ,    (self.batch_size, self.projection_dim or self.hidden_size)    )

	def        UpperCamelCase    (							self       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			TFDPRReader(config=UpperCAmelCase    )
							_UpperCAmelCase									=			model(UpperCAmelCase       ,    attention_mask=UpperCAmelCase    )

							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)    )
							self.parent.assertEqual(result.relevance_logits.shape       ,    (self.batch_size,)    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			self.prepare_config_and_inputs()
							(
							    (
							    _UpperCAmelCase
							)					, (
							    _UpperCAmelCase
							)					, (
							    _UpperCAmelCase
							)					, (
							    _UpperCAmelCase
							)					, (
							    _UpperCAmelCase
							)					, (
							    _UpperCAmelCase
							)					, (
							    _UpperCAmelCase
							)					, 
							)									=			config_and_inputs
							_UpperCAmelCase									=			{'input_ids': input_ids}
							return config, inputs_dict





@require_tf
class __lowerCamelCase (      snake_case__     ,       snake_case__     ,       unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__								=      (
	    (
	        TFDPRContextEncoder,
	        TFDPRQuestionEncoder,
	        TFDPRReader,
	    )
	    if is_tf_available()
	    else ()
	)
	UpperCamelCase__								=      {"feature-extraction": TFDPRQuestionEncoder} if is_tf_available() else {}

	UpperCamelCase__								=      False
	UpperCamelCase__								=      False
	UpperCamelCase__								=      False
	UpperCamelCase__								=      False
	UpperCamelCase__								=      False

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			TFDPRModelTester(self    )
							_UpperCAmelCase									=			ConfigTester(self       ,    config_class=UpperCAmelCase       ,    hidden_size=37    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							self.config_tester.run_common_tests()

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_context_encoder(*UpperCAmelCase    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_question_encoder(*UpperCAmelCase    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_reader(*UpperCAmelCase    )

	@slow
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_UpperCAmelCase									=			TFDPRContextEncoder.from_pretrained(UpperCAmelCase    )
													self.assertIsNotNone(UpperCAmelCase    )

							for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_UpperCAmelCase									=			TFDPRContextEncoder.from_pretrained(UpperCAmelCase    )
													self.assertIsNotNone(UpperCAmelCase    )

							for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_UpperCAmelCase									=			TFDPRQuestionEncoder.from_pretrained(UpperCAmelCase    )
													self.assertIsNotNone(UpperCAmelCase    )

							for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													_UpperCAmelCase									=			TFDPRReader.from_pretrained(UpperCAmelCase    )
													self.assertIsNotNone(UpperCAmelCase    )





@require_tf
class __lowerCamelCase (      unittest.TestCase):





	"""simple docstring"""






	@slow
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			TFDPRQuestionEncoder.from_pretrained('facebook/dpr-question_encoder-single-nq-base'    )

							_UpperCAmelCase									=			tf.constant(
							    [[101, 7592, 1010, 2003, 2026, 3899, 1_0140, 1029, 102]]    )  # [CLS] hello, is my dog cute? [SEP]
							_UpperCAmelCase									=			model(UpperCAmelCase    )[0]  # embedding shape = (1, 768)
							# compare the actual values for a slice.
							_UpperCAmelCase									=			tf.constant(
							    [
							        [
							            0.03_23_62_53,
							            0.12_75_33_35,
							            0.16_81_85_09,
							            0.00_27_97_86,
							            0.3_89_69_33,
							            0.24_26_49_45,
							            0.2_17_89_71,
							            -0.02_33_52_27,
							            -0.08_48_19_59,
							            -0.14_32_41_17,
							        ]
							    ]    )
							self.assertTrue(numpy.allclose(output[:, :10].numpy()       ,    expected_slice.numpy()       ,    atol=1e-4    )    )








from __future__ import annotations




def      lowercase__      (     __snake_case    :							tuple[int, int]     ,       __snake_case    :							int  ):


					'''simple docstring'''


					UpperCAmelCase_       ,  UpperCAmelCase_    :      Tuple            =						position
					UpperCAmelCase_    :      str            =						[
					    (y + 1, x + 2),
					    (y - 1, x + 2),
					    (y + 1, x - 2),
					    (y - 1, x - 2),
					    (y + 2, x + 1),
					    (y + 2, x - 1),
					    (y - 2, x + 1),
					    (y - 2, x - 1),
					]
					UpperCAmelCase_    :      Optional[Any]            =						[]

					for position in positions:
										UpperCAmelCase_       ,  UpperCAmelCase_    :      Tuple            =						position
										if 0 <= y_test < n and 0 <= x_test < n:
															permissible_positions.append(__snake_case  )

					return permissible_positions




def      lowercase__      (     __snake_case    :							list[list[int]]  ):


					'''simple docstring'''


					return not any(elem == 0 for row in board for elem in row  )




def      lowercase__      (     __snake_case    :							list[list[int]]     ,       __snake_case    :							tuple[int, int]     ,       __snake_case    :							int  ):


					'''simple docstring'''


					if is_complete(__snake_case  ):
										return True

					for position in get_valid_pos(__snake_case     ,       len(__snake_case  )  ):
										UpperCAmelCase_       ,  UpperCAmelCase_    :      Any            =						position

										if board[y][x] == 0:
															UpperCAmelCase_    :      Optional[Any]            =						curr + 1
															if open_knight_tour_helper(__snake_case     ,       __snake_case     ,       curr + 1  ):
																				return True
															UpperCAmelCase_    :      List[Any]            =						0

					return False




def      lowercase__      (     __snake_case    :							int  ):


					'''simple docstring'''


					UpperCAmelCase_    :      str            =						[[0 for i in range(__snake_case  )] for j in range(__snake_case  )]

					for i in range(__snake_case  ):
										for j in range(__snake_case  ):
															UpperCAmelCase_    :      Optional[Any]            =						1
															if open_knight_tour_helper(__snake_case     ,       (i, j)     ,       1  ):
																				return board
															UpperCAmelCase_    :      List[Any]            =						0

					UpperCAmelCase_    :      List[str]            =						F"Open Kight Tour cannot be performed on a board of size {n}"
					raise ValueError(__snake_case  )


if __name__ == "__main__":
		import doctest

		doctest.testmod()






