


'''simple docstring'''
import unittest

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

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    LiltForQuestionAnswering,
					    LiltForSequenceClassification,
					    LiltForTokenClassification,
					    LiltModel,
					)
					from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST




class        _UpperCamelCase	:


				'''simple docstring'''


				def __init__(     self							,      a_							,      a_=1_3							,      a_=7							,      a_=True							,      a_=True							,      a_=True							,      a_=True							,      a_=9_9							,      a_=2_4							,      a_=2							,      a_=6							,      a_=3_7							,      a_="gelu"							,      a_=0.1							,      a_=0.1							,      a_=5_1_2							,      a_=1_6							,      a_=2							,      a_=0.02							,      a_=3							,      a_=None							,      a_=1_0_0_0							,      )    ->  Optional[Any]:
					lowercase						:		str   					=		parent
					lowercase						:		int   					=		batch_size
					lowercase						:		List[Any]   					=		seq_length
					lowercase						:		Optional[int]   					=		is_training
					lowercase						:		int   					=		use_input_mask
					lowercase						:		Dict   					=		use_token_type_ids
					lowercase						:		Union[str, Any]   					=		use_labels
					lowercase						:		int   					=		vocab_size
					lowercase						:		List[str]   					=		hidden_size
					lowercase						:		str   					=		num_hidden_layers
					lowercase						:		List[Any]   					=		num_attention_heads
					lowercase						:		Tuple   					=		intermediate_size
					lowercase						:		Any   					=		hidden_act
					lowercase						:		Optional[int]   					=		hidden_dropout_prob
					lowercase						:		Any   					=		attention_probs_dropout_prob
					lowercase						:		Optional[Any]   					=		max_position_embeddings
					lowercase						:		Optional[int]   					=		type_vocab_size
					lowercase						:		List[str]   					=		type_sequence_label_size
					lowercase						:		List[str]   					=		initializer_range
					lowercase						:		str   					=		num_labels
					lowercase						:		str   					=		scope
					lowercase						:		List[str]   					=		range_bbox

				def 	a__		(     self							)    ->  List[Any]:
					lowercase						:		Dict   					=		ids_tensor([self.batch_size, self.seq_length]							,      self.vocab_size							)

					lowercase						:		Union[str, Any]   					=		ids_tensor([self.batch_size, self.seq_length, 4]							,      self.range_bbox							)
					# Ensure that bbox is legal
					for i in range(bbox.shape[0]							):
						for j in range(bbox.shape[1]							):
							if bbox[i, j, 3] < bbox[i, j, 1]:
								lowercase						:		Any   					=		bbox[i, j, 3]
								lowercase						:		Union[str, Any]   					=		bbox[i, j, 1]
								lowercase						:		List[str]   					=		t
							if bbox[i, j, 2] < bbox[i, j, 0]:
								lowercase						:		List[Any]   					=		bbox[i, j, 2]
								lowercase						:		Dict   					=		bbox[i, j, 0]
								lowercase						:		Union[str, Any]   					=		t

					lowercase						:		List[str]   					=		None
					if self.use_input_mask:
						lowercase						:		Union[str, Any]   					=		ids_tensor([self.batch_size, self.seq_length]							,      vocab_size=2							)

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

					lowercase						:		Tuple   					=		None
					lowercase						:		Tuple   					=		None
					if self.use_labels:
						lowercase						:		str   					=		ids_tensor([self.batch_size]							,      self.type_sequence_label_size							)
						lowercase						:		Any   					=		ids_tensor([self.batch_size, self.seq_length]							,      self.num_labels							)

					lowercase						:		Tuple   					=		self.get_config()

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

				def 	a__		(     self							)    ->  Optional[Any]:
					return LiltConfig(
					    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							,      )

				def 	a__		(     self							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      )    ->  Dict:
					lowercase						:		Any   					=		LiltModel(config=a_							)
					model.to(a_							)
					model.eval()
					lowercase						:		Optional[Any]   					=		model(a_							,      bbox=a_							,      attention_mask=a_							,      token_type_ids=a_							)
					lowercase						:		Optional[Any]   					=		model(a_							,      bbox=a_							,      token_type_ids=a_							)
					lowercase						:		List[str]   					=		model(a_							,      bbox=a_							)

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

				def 	a__		(     self							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      )    ->  int:
					lowercase						:		Union[str, Any]   					=		self.num_labels
					lowercase						:		List[Any]   					=		LiltForTokenClassification(config=a_							)
					model.to(a_							)
					model.eval()
					lowercase						:		int   					=		model(
					    a_							,      bbox=a_							,      attention_mask=a_							,      token_type_ids=a_							,      labels=a_							)
					self.parent.assertEqual(result.logits.shape							,      (self.batch_size, self.seq_length, self.num_labels)							)

				def 	a__		(     self							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      a_							,      )    ->  List[Any]:
					lowercase						:		str   					=		LiltForQuestionAnswering(config=a_							)
					model.to(a_							)
					model.eval()
					lowercase						:		Dict   					=		model(
					    a_							,      bbox=a_							,      attention_mask=a_							,      token_type_ids=a_							,      start_positions=a_							,      end_positions=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 	a__		(     self							)    ->  List[Any]:
					lowercase						:		Tuple   					=		self.prepare_config_and_inputs()
					(
					    (
					    lowercase
					)					,		(
					    lowercase
					)					,		(
					    lowercase
					)					,		(
					    lowercase
					)					,		(
					    lowercase
					)					,		(
					    lowercase
					)					,		(
					    lowercase
					)					,		
					)						:		Optional[int]   					=		config_and_inputs
					lowercase						:		List[str]   					=		{
					    "input_ids": input_ids,
					    "bbox": bbox,
					    "token_type_ids": token_type_ids,
					    "attention_mask": input_mask,
					}
					return config, inputs_dict




@require_torch
class        _UpperCamelCase	(    SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			unittest.TestCase):


				'''simple docstring'''


				_snake_case						       =				(
				    (
				        LiltModel,
				        LiltForSequenceClassification,
				        LiltForTokenClassification,
				        LiltForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				_snake_case						       =				(
				    {
				        '''feature-extraction''': LiltModel,
				        '''question-answering''': LiltForQuestionAnswering,
				        '''text-classification''': LiltForSequenceClassification,
				        '''token-classification''': LiltForTokenClassification,
				        '''zero-shot''': LiltForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				_snake_case						       =				False
				_snake_case						       =				False

				def 	a__		(     self							,      a_							,      a_							,      a_							,      a_							,      a_							)    ->  Dict:
					return True

				def 	a__		(     self							)    ->  Optional[Any]:
					lowercase						:		Optional[int]   					=		LiltModelTester(self							)
					lowercase						:		Any   					=		ConfigTester(self							,      config_class=a_							,      hidden_size=3_7							)

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

				def 	a__		(     self							)    ->  Tuple:
					lowercase						:		Optional[Any]   					=		self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*a_							)

				def 	a__		(     self							)    ->  List[str]:
					lowercase						:		int   					=		self.model_tester.prepare_config_and_inputs()
					for type in ["absolute", "relative_key", "relative_key_query"]:
						lowercase						:		Optional[Any]   					=		type
						self.model_tester.create_and_check_model(*a_							)

				def 	a__		(     self							)    ->  int:
					lowercase						:		Optional[int]   					=		self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*a_							)

				def 	a__		(     self							)    ->  Dict:
					lowercase						:		List[str]   					=		self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*a_							)


				@slow
				def 	a__		(     self							)    ->  Any:
					for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase						:		Optional[int]   					=		LiltModel.from_pretrained(a_							)
						self.assertIsNotNone(a_							)




@require_torch
@slow
class        _UpperCamelCase	(    unittest.TestCase):


				'''simple docstring'''


				def 	a__		(     self							)    ->  Union[str, Any]:
					lowercase						:		Any   					=		LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"							).to(a_							)

					lowercase						:		List[Any]   					=		torch.tensor([[1, 2]]							,      device=a_							)
					lowercase						:		Any   					=		torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]							,      device=a_							)

					# forward pass
					with torch.no_grad():
						lowercase						:		int   					=		model(input_ids=a_							,      bbox=a_							)

					lowercase						:		Union[str, Any]   					=		torch.Size([1, 2, 7_6_8]							)
					lowercase						:		int   					=		torch.tensor(
					    [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]							,      device=a_							,      )

					self.assertTrue(outputs.last_hidden_state.shape							,      a_							)
					self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]							,      a_							,      atol=1e-3							)							)






'''simple docstring'''
from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


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 .multicontrolnet import MultiControlNetModel
					from .pipeline_controlnet import StableDiffusionControlNetPipeline
					from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
					from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
					from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline


