






import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
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 (
					    MODEL_FOR_PRETRAINING_MAPPING,
					    ElectraForCausalLM,
					    ElectraForMaskedLM,
					    ElectraForMultipleChoice,
					    ElectraForPreTraining,
					    ElectraForQuestionAnswering,
					    ElectraForSequenceClassification,
					    ElectraForTokenClassification,
					    ElectraModel,
					)
					from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST
class   UpperCamelCase			:







		"""simple docstring"""



		def __init__(	self		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]=1_3    ,_SCREAMING_SNAKE_CASE		:							List[Any]=7    ,_SCREAMING_SNAKE_CASE		:							Any=True    ,_SCREAMING_SNAKE_CASE		:							Dict=True    ,_SCREAMING_SNAKE_CASE		:							List[Any]=True    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]=True    ,_SCREAMING_SNAKE_CASE		:							int=9_9    ,_SCREAMING_SNAKE_CASE		:							Optional[int]=3_2    ,_SCREAMING_SNAKE_CASE		:							Dict=5    ,_SCREAMING_SNAKE_CASE		:							Optional[int]=4    ,_SCREAMING_SNAKE_CASE		:							int=3_7    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]="gelu"    ,_SCREAMING_SNAKE_CASE		:							List[str]=0.1    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]=0.1    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]=5_1_2    ,_SCREAMING_SNAKE_CASE		:							Any=1_6    ,_SCREAMING_SNAKE_CASE		:							Optional[int]=2    ,_SCREAMING_SNAKE_CASE		:							List[Any]=0.02    ,_SCREAMING_SNAKE_CASE		:							List[Any]=3    ,_SCREAMING_SNAKE_CASE		:							Any=4    ,_SCREAMING_SNAKE_CASE		:							Any=None    ,)     -> Dict:


						'''simple docstring'''
						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    A(	self		:							Optional[int]		)     -> Dict:


						'''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									=   ids_tensor([self.batch_size, self.seq_length]    ,1		)

						A									=   self.get_config()

						return (
						    config,
						    input_ids,
						    token_type_ids,
						    input_mask,
						    sequence_labels,
						    token_labels,
						    choice_labels,
						    fake_token_labels,
						)
		def    A(	self		:							List[str]		)     -> str:


						'''simple docstring'''
						return ElectraConfig(
						    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=_SCREAMING_SNAKE_CASE    ,initializer_range=self.initializer_range    ,)
		def    A(	self		:							List[str]		)     -> Any:


						'''simple docstring'''
						(
						    (
						    A
						)			,		(
						    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    A(	self		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,)     -> str:


						'''simple docstring'''
						A									=   ElectraModel(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE		)
						A									=   model(_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE		)
						A									=   model(_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.last_hidden_state.shape    ,(self.batch_size, self.seq_length, self.hidden_size)		)
		def    A(	self		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,)     -> Tuple:


						'''simple docstring'''
						A									=   True
						A									=   ElectraModel(_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(
						    _SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,encoder_hidden_states=_SCREAMING_SNAKE_CASE    ,encoder_attention_mask=_SCREAMING_SNAKE_CASE    ,)
						A									=   model(
						    _SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,encoder_hidden_states=_SCREAMING_SNAKE_CASE    ,)
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.last_hidden_state.shape    ,(self.batch_size, self.seq_length, self.hidden_size)		)
		def    A(	self		:							Any    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							int    ,)     -> List[str]:


						'''simple docstring'''
						A									=   ElectraForMaskedLM(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,labels=_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.seq_length, self.vocab_size)		)
		def    A(	self		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,)     -> int:


						'''simple docstring'''
						A									=   ElectraForCausalLM(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,labels=_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.seq_length, self.vocab_size)		)
		def    A(	self		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							str    ,)     -> Optional[Any]:


						'''simple docstring'''
						A									=   self.num_labels
						A									=   ElectraForTokenClassification(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,labels=_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.seq_length, self.num_labels)		)
		def    A(	self		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							str    ,)     -> Any:


						'''simple docstring'''
						A									=   self.num_labels
						A									=   ElectraForPreTraining(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,labels=_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.seq_length)		)
		def    A(	self		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,)     -> Dict:


						'''simple docstring'''
						A									=   self.num_labels
						A									=   ElectraForSequenceClassification(_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,labels=_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.num_labels)		)
		def    A(	self		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							Dict    ,)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   ElectraForQuestionAnswering(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_SNAKE_CASE		)
						model.eval()
						A									=   model(
						    _SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,start_positions=_SCREAMING_SNAKE_CASE    ,end_positions=_SCREAMING_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    A(	self		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,)     -> Optional[int]:


						'''simple docstring'''
						A									=   self.num_choices
						A									=   ElectraForMultipleChoice(config=_SCREAMING_SNAKE_CASE		)
						model.to(_SCREAMING_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(
						    _SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE    ,token_type_ids=_SCREAMING_SNAKE_CASE    ,labels=_SCREAMING_SNAKE_CASE    ,)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.num_choices)		)







		def    A(	self		:							int		)     -> Optional[Any]:


						'''simple docstring'''
						A									=   self.prepare_config_and_inputs()
						(
						    (
						    A
						)			,		(
						    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   UpperCamelCase			(					snake_case__      ,							snake_case__      ,							unittest.TestCase			):







		"""simple docstring"""



		snake_case			 = (
		    (
		        ElectraModel,
		        ElectraForPreTraining,
		        ElectraForMaskedLM,
		        ElectraForCausalLM,
		        ElectraForMultipleChoice,
		        ElectraForTokenClassification,
		        ElectraForSequenceClassification,
		        ElectraForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		snake_case			 = (
		    {
		        "feature-extraction": ElectraModel,
		        "fill-mask": ElectraForMaskedLM,
		        "question-answering": ElectraForQuestionAnswering,
		        "text-classification": ElectraForSequenceClassification,
		        "text-generation": ElectraForCausalLM,
		        "token-classification": ElectraForTokenClassification,
		        "zero-shot": ElectraForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		snake_case			 = True
		def    A(	self		:							str    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							Optional[int]=False		)     -> List[str]:


						'''simple docstring'''
						A									=   super()._prepare_for_class(_SCREAMING_SNAKE_CASE    ,_SCREAMING_SNAKE_CASE    ,return_labels=_SCREAMING_SNAKE_CASE		)

						if return_labels:
										if model_class in get_values(_SCREAMING_SNAKE_CASE		):
														A									=   torch.zeros(
														    (self.model_tester.batch_size, self.model_tester.seq_length)    ,dtype=torch.long    ,device=_SCREAMING_SNAKE_CASE		)
						return inputs_dict
		def    A(	self		:							Dict		)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   ElectraModelTester(self		)
						A									=   ConfigTester(self    ,config_class=_SCREAMING_SNAKE_CASE    ,hidden_size=3_7		)
		def    A(	self		:							Any		)     -> Union[str, Any]:


						'''simple docstring'''
						self.config_tester.run_common_tests()
		def    A(	self		:							Dict		)     -> str:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_model(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Optional[Any]		)     -> List[str]:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs_for_decoder()
						self.model_tester.create_and_check_electra_model_as_decoder(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Union[str, Any]		)     -> str:


						'''simple docstring'''
						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_electra_model(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Tuple		)     -> str:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_masked_lm(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Dict		)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_token_classification(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Union[str, Any]		)     -> Tuple:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_pretraining(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							List[str]		)     -> Tuple:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_sequence_classification(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							str		)     -> Any:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_question_answering(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Union[str, Any]		)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_electra_for_multiple_choice(*_SCREAMING_SNAKE_CASE		)
		@slow
		def    A(	self		:							List[str]		)     -> str:


						'''simple docstring'''
						for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										A									=   ElectraModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)







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


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs_for_decoder()
						self.model_tester.create_and_check_electra_for_causal_lm(*_SCREAMING_SNAKE_CASE		)


@require_torch
class   UpperCamelCase			(					unittest.TestCase			):







		"""simple docstring"""



		@slow
		def    A(	self		:							List[str]		)     -> Any:


						'''simple docstring'''
						A									=   ElectraModel.from_pretrained('google/electra-small-discriminator'		)
						A									=   torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]		)
						A									=   torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]		)
						A									=   model(_SCREAMING_SNAKE_CASE    ,attention_mask=_SCREAMING_SNAKE_CASE		)[0]
						A									=   torch.Size((1, 1_1, 2_5_6)		)
						self.assertEqual(output.shape    ,_SCREAMING_SNAKE_CASE		)
						A									=   torch.tensor(
						    [[[0.4471, 0.6821, -0.3265], [0.4627, 0.5255, -0.3668], [0.4532, 0.3313, -0.4344]]]		)

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













def   snake_case		(				UpperCAmelCase						:							set,    UpperCAmelCase						:							set ):
				assert isinstance(UpperCAmelCase,    UpperCAmelCase ), f'The input value of [set_a={set_a}] is not a set'
				assert isinstance(UpperCAmelCase,    UpperCAmelCase ), f'The input value of [set_b={set_b}] is not a set'

				return {a + b for a in set_a for b in set_b}


if __name__ == "__main__":
					from doctest import testmod

					testmod()





