





import unittest

from parameterized import parameterized

from transformers import LlamaConfig, is_torch_available, set_seed
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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaTokenizer

class 		SCREAMING_SNAKE_CASE__				:


      def __init__(self       :      int				,			a__       :      Optional[int]				,			a__       :      List[Any]=13				,			a__       :      Dict=7				,			a__       :      str=True				,			a__       :      str=True				,			a__       :      Optional[int]=False				,			a__       :      Optional[int]=True				,			a__       :      Union[str, Any]=99				,			a__       :      Optional[int]=32				,			a__       :      Optional[int]=5				,			a__       :      Optional[Any]=4				,			a__       :      str=37				,			a__       :      Union[str, Any]="gelu"				,			a__       :      int=0.1				,			a__       :      List[Any]=0.1				,			a__       :      Dict=512				,			a__       :      Optional[int]=16				,			a__       :      List[Any]=2				,			a__       :      str=0.0_2				,			a__       :      int=3				,			a__       :      Tuple=4				,			a__       :      Optional[Any]=None				,			):





         """simple docstring"""



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


      def    a (self       :      List[Any]      ):





         """simple docstring"""



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

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

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

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

         __snake_case							       =   self.get_config()

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


      def    a (self       :      str      ):





         """simple docstring"""



         return LlamaConfig(
             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=a__				,			initializer_range=self.initializer_range				,			)


      def    a (self       :      str				,			a__       :      int				,			a__       :      str				,			a__       :      Union[str, Any]				,			a__       :      Optional[Any]				,			a__       :      Optional[int]				,			a__       :      Optional[Any]				,			a__       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   LlamaModel(config=a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__      )
         __snake_case							       =   model(a__      )
         self.parent.assertEqual(result.last_hidden_state.shape				,			(self.batch_size, self.seq_length, self.hidden_size)      )


      def    a (self       :      Optional[Any]				,			a__       :      str				,			a__       :      List[Any]				,			a__       :      Dict				,			a__       :      Any				,			a__       :      Tuple				,			a__       :      Optional[int]				,			a__       :      List[str]				,			a__       :      Optional[Any]				,			a__       :      Dict				,			):





         """simple docstring"""



         __snake_case							       =   True
         __snake_case							       =   LlamaModel(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			)
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			)
         __snake_case							       =   model(a__				,			attention_mask=a__      )
         self.parent.assertEqual(result.last_hidden_state.shape				,			(self.batch_size, self.seq_length, self.hidden_size)      )


      def    a (self       :      Any				,			a__       :      Union[str, Any]				,			a__       :      Tuple				,			a__       :      Tuple				,			a__       :      int				,			a__       :      int				,			a__       :      str				,			a__       :      int				,			a__       :      List[Any]				,			a__       :      List[Any]				,			):





         """simple docstring"""



         __snake_case							       =   LlamaForCausalLM(config=a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.seq_length, self.vocab_size)      )


      def    a (self       :      int				,			a__       :      str				,			a__       :      Tuple				,			a__       :      Union[str, Any]				,			a__       :      Optional[int]				,			a__       :      Any				,			a__       :      str				,			a__       :      Optional[int]				,			a__       :      Union[str, Any]				,			a__       :      int				,			):





         """simple docstring"""



         __snake_case							       =   True
         __snake_case							       =   True
         __snake_case							       =   LlamaForCausalLM(config=a__      )
         model.to(a__      )
         model.eval()

         # first forward pass
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			use_cache=a__				,			)
         __snake_case							       =   outputs.past_key_values

         # create hypothetical multiple next token and extent to next_input_ids
         __snake_case							       =   ids_tensor((self.batch_size, 3)				,			config.vocab_size      )
         __snake_case							       =   ids_tensor((self.batch_size, 3)				,			vocab_size=2      )

         # append to next input_ids and
         __snake_case							       =   torch.cat([input_ids, next_tokens]				,			dim=-1      )
         __snake_case							       =   torch.cat([input_mask, next_mask]				,			dim=-1      )

         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			output_hidden_states=a__				,			)['''hidden_states'''][0]
         __snake_case							       =   model(
             a__				,			attention_mask=a__				,			encoder_hidden_states=a__				,			encoder_attention_mask=a__				,			past_key_values=a__				,			output_hidden_states=a__				,			)['''hidden_states'''][0]

         # select random slice
         __snake_case							       =   ids_tensor((1,)				,			output_from_past.shape[-1]      ).item()
         __snake_case							       =   output_from_no_past[:, -3:, random_slice_idx].detach()
         __snake_case							       =   output_from_past[:, :, random_slice_idx].detach()

         self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]      )

         # test that outputs are equal for slice
         self.parent.assertTrue(torch.allclose(a__				,			a__				,			atol=1E-3      )      )


      def    a (self       :      Dict      ):





         """simple docstring"""



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






@require_torch
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				List[Any]							=    (LlamaModel, LlamaForCausalLM, LlamaForSequenceClassification) if is_torch_available() else ()
      A_						:				List[str]							=    (LlamaForCausalLM,) if is_torch_available() else ()
      A_						:				Dict							=    (
          {
              'feature-extraction': LlamaModel,
              'text-classification': LlamaForSequenceClassification,
              'text-generation': LlamaForCausalLM,
              'zero-shot': LlamaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      A_						:				Any							=    False
      A_						:				Union[str, Any]							=    False


      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         __snake_case							       =   LlamaModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__				,			hidden_size=37      )


      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         self.config_tester.run_common_tests()


      def    a (self       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*a__      )


      def    a (self       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
            __snake_case							       =   type
            self.model_tester.create_and_check_model(*a__      )


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   3
         __snake_case							       =   input_dict['''input_ids''']
         __snake_case							       =   input_ids.ne(1      ).to(a__      )
         __snake_case							       =   ids_tensor([self.model_tester.batch_size]				,			self.model_tester.type_sequence_label_size      )
         __snake_case							       =   LlamaForSequenceClassification(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.assertEqual(result.logits.shape				,			(self.model_tester.batch_size, self.model_tester.num_labels)      )


      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   3
         __snake_case							       =   '''single_label_classification'''
         __snake_case							       =   input_dict['''input_ids''']
         __snake_case							       =   input_ids.ne(1      ).to(a__      )
         __snake_case							       =   ids_tensor([self.model_tester.batch_size]				,			self.model_tester.type_sequence_label_size      )
         __snake_case							       =   LlamaForSequenceClassification(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.assertEqual(result.logits.shape				,			(self.model_tester.batch_size, self.model_tester.num_labels)      )


      def    a (self       :      List[Any]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   3
         __snake_case							       =   '''multi_label_classification'''
         __snake_case							       =   input_dict['''input_ids''']
         __snake_case							       =   input_ids.ne(1      ).to(a__      )
         __snake_case							       =   ids_tensor(
             [self.model_tester.batch_size, config.num_labels]				,			self.model_tester.type_sequence_label_size      ).to(torch.float      )
         __snake_case							       =   LlamaForSequenceClassification(a__      )
         model.to(a__      )
         model.eval()
         __snake_case							       =   model(a__				,			attention_mask=a__				,			labels=a__      )
         self.assertEqual(result.logits.shape				,			(self.model_tester.batch_size, self.model_tester.num_labels)      )


      @unittest.skip('''LLaMA buffers include complex numbers, which breaks this test'''      )
      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         pass


      @parameterized.expand([('''linear''',), ('''dynamic''',)]      )
      def    a (self       :      Optional[Any]				,			a__       :      Optional[int]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   ids_tensor([1, 10]				,			config.vocab_size      )
         __snake_case							       =   ids_tensor([1, int(config.max_position_embeddings * 1.5      )]				,			config.vocab_size      )

         set_seed(42      )  # Fixed seed at init time so the two models get the same random weights
         __snake_case							       =   LlamaModel(a__      )
         original_model.to(a__      )
         original_model.eval()
         __snake_case							       =   original_model(a__      ).last_hidden_state
         __snake_case							       =   original_model(a__      ).last_hidden_state

         set_seed(42      )  # Fixed seed at init time so the two models get the same random weights
         __snake_case							       =   {'''type''': scaling_type, '''factor''': 1_0.0}
         __snake_case							       =   LlamaModel(a__      )
         scaled_model.to(a__      )
         scaled_model.eval()
         __snake_case							       =   scaled_model(a__      ).last_hidden_state
         __snake_case							       =   scaled_model(a__      ).last_hidden_state

         # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
         # maximum sequence length, so the outputs for the short input should match.
         if scaling_type == "dynamic":
            self.assertTrue(torch.allclose(a__				,			a__				,			atol=1E-5      )      )
         else:
            self.assertFalse(torch.allclose(a__				,			a__				,			atol=1E-5      )      )

         # The output should be different for long inputs
         self.assertFalse(torch.allclose(a__				,			a__				,			atol=1E-5      )      )






@require_torch
class 		SCREAMING_SNAKE_CASE__				(       unittest.TestCase  ):


      @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!'''      )
      @slow
      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-7b-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor([input_ids]      )      )
         # Expected mean on dim = -1
         __snake_case							       =   torch.tensor([[-6.6_5_5_0, -4.1_2_2_7, -4.9_8_5_9, -3.2_4_0_6, 0.8_2_6_2, -3.0_0_3_3, 1.2_9_6_4, -3.3_6_9_9]]      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         __snake_case							       =   torch.tensor([-1_2.8_2_8_1, -7.4_4_5_3, -0.4_6_3_9, -8.0_6_2_5, -7.2_5_0_0, -8.0_0_0_0, -6.4_8_8_3, -7.7_6_9_5, -7.8_4_3_8, -7.0_3_1_2, -6.2_1_8_8, -7.1_3_2_8, -1.8_4_9_6, 1.9_9_6_1, -8.6_2_5_0, -6.7_2_2_7, -1_2.8_2_8_1, -6.9_4_9_2, -7.0_7_4_2, -7.7_8_5_2, -7.5_8_2_0, -7.9_0_6_2, -6.9_3_7_5, -7.9_8_0_5, -8.3_4_3_8, -8.1_5_6_2, -8.0_4_6_9, -7.6_2_5_0, -7.7_4_2_2, -7.3_3_9_8,]      )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :30]				,			a__				,			atol=1E-5				,			rtol=1E-5      )


      @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!'''      )
      @slow
      def    a (self       :      str      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor(a__      )      )
         # Expected mean on dim = -1
         __snake_case							       =   torch.tensor([[-2.0_6_2_2, -1.2_7_9_4, -1.1_6_3_8, -0.9_7_8_8, -1.4_6_0_3, -1.0_2_3_8, -1.7_8_9_3, -1.4_4_1_1]]      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         __snake_case							       =   torch.tensor([-8.1_4_0_6, -8.0_5_4_7, 2.7_4_6_1, -1.2_3_4_4, -0.1_4_4_8, -1.8_2_6_2, -1.0_0_2_0, -1.8_1_5_4, -1.6_8_9_5, -1.8_5_1_6, -2.3_5_7_4, -0.9_2_7_7, 3.7_5_9_8, 6.5_7_4_2, -1.2_9_9_8, -0.1_1_7_7, -8.1_4_0_6, -2.9_6_8_8, -2.9_1_9_9, -3.1_6_9_9, -3.5_2_5_4, -2.3_5_5_5, -2.7_9_8_8, -3.4_1_4_1, -2.8_2_6_2, -4.5_1_9_5, -3.3_3_7_9, -3.3_1_6_4, -2.7_8_3_2, -3.0_2_7_3]      )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :30]				,			a__				,			atol=1E-5				,			rtol=1E-5      )


      @unittest.skip('''Logits are not exactly the same, once we fix the instabalities somehow, will update!'''      )
      @slow
      def    a (self       :      Any      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor(a__      )      )
         # Expected mean on dim = -1
         __snake_case							       =   torch.tensor([[-0.8_5_6_2, -1.8_5_2_0, -0.7_5_5_1, -0.4_1_6_2, -1.5_1_6_1, -1.2_0_3_8, -2.4_8_2_3, -2.3_2_5_4]]      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # slicing logits[0, 0, 0:30]
         # fmt: off
         __snake_case							       =   torch.tensor([-2.2_2_2_7, 4.8_8_2_8, 0.9_0_2_3, -0.4_5_7_8, -0.7_8_7_1, -0.1_0_3_3, -0.6_2_2_1, -0.5_7_8_6, -0.7_8_0_3, -1.0_6_7_4, -1.2_9_2_0, -0.1_5_7_0, 0.8_0_0_8, 2.0_7_2_3, -0.9_4_9_7, 0.2_7_7_1, -2.2_2_2_7, -0.7_6_1_2, -1.4_3_4_6, -1.2_0_6_1, -1.6_4_2_6, -0.3_0_0_0, -0.7_1_3_9, -1.1_9_3_4, -1.8_6_9_1, -1.6_9_7_3, -1.5_9_4_7, -1.2_7_0_5, -0.3_5_2_3, -0.5_5_1_3]      )
         # fmt: on
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )


      @unittest.skip(
          '''Logits are not exactly the same, once we fix the instabalities somehow, will update! Also it is gonna be a `too_slow` test'''      )
      @slow
      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case							       =   [1, 306, 4658, 278, 6593, 310, 2834, 338]
         __snake_case							       =   LlamaForCausalLM.from_pretrained('''meta-llama/Llama-2-70b-hf'''				,			device_map='''auto'''      )
         __snake_case							       =   model(torch.tensor(a__      )      )

         __snake_case							       =   torch.tensor(
             [[-4.2_3_2_7, -3.3_3_6_0, -4.6_6_6_5, -4.7_6_3_1, -1.8_1_8_0, -3.4_1_7_0, -1.4_2_1_1, -3.1_8_1_0]]				,			dtype=torch.floataa      )
         torch.testing.assert_close(out.mean(-1      )				,			a__				,			atol=1E-2				,			rtol=1E-2      )
         # fmt: off
         __snake_case							       =   torch.tensor([-9.4_9_2_2, -3.9_5_5_1, 1.7_9_9_8, -5.6_7_5_8, -5.1_0_5_5, -5.8_9_8_4, -4.8_3_2_0, -6.8_0_8_6, -6.5_3_9_1, -5.6_1_7_2, -5.5_8_2_0, -5.5_3_5_2, 1.7_8_8_1, 3.6_2_8_9, -6.5_1_1_7, -3.4_7_8_5, -9.5_0_0_0, -6.0_3_5_2, -6.8_1_2_5, -6.0_1_9_5, -6.6_8_3_6, -5.4_7_2_7, -6.2_8_1_2, -6.0_3_9_1, -7.3_3_9_8, -7.4_2_9_7, -7.4_8_4_4, -6.5_8_2_0, -5.8_7_8_9, -5.5_3_1_2]      )
         # fmt: on
         torch.testing.assert_close(out[0, 0, :30]				,			a__				,			atol=1E-5				,			rtol=1E-5      )


      @unittest.skip('''Model is curently gated'''      )
      @slow
      def    a (self       :      List[str]      ):





         """simple docstring"""



         __snake_case							       =   '''Simply put, the theory of relativity states that 1) the laws of physics are the same everywhere in the universe and 2) the passage of time and the length of objects can vary depending on the observer\'s frame of reference.\n\nThe first part of the theory, that the laws of physics are the same everywhere, is known as the "princi'''
         __snake_case							       =   '''Simply put, the theory of relativity states that '''
         __snake_case							       =   LlamaTokenizer.from_pretrained('''meta-llama/Llama-2-13b-chat-hf'''      )
         __snake_case							       =   tokenizer.encode(a__				,			return_tensors='''pt'''      )
         __snake_case							       =   LlamaForCausalLM.from_pretrained(
             '''meta-llama/Llama-2-13b-chat-hf'''				,			device_map='''sequential'''				,			use_safetensors=a__      )

         # greedy generation outputs
         __snake_case							       =   model.generate(a__				,			max_new_tokens=64				,			top_p=a__				,			temperature=1				,			do_sample=a__      )
         __snake_case							       =   tokenizer.decode(generated_ids[0]				,			skip_special_tokens=a__      )
         self.assertEqual(a__				,			a__      )








def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     set:
    lowerCamelCase__    :      Optional[Any]					 =		set()
    # edges = list of graph's edges
    lowerCamelCase__    :      List[str]					 =		get_edges(_UpperCAmelCase )

    # While there are still elements in edges list, take an arbitrary edge
    # (from_node, to_node) and add his extremity to chosen_vertices and then
    # remove all arcs adjacent to the from_node and to_node
    while edges:
        lowerCamelCase__ ,							lowerCamelCase__    :      str					 =		edges.pop()
        chosen_vertices.add(_UpperCAmelCase )
        chosen_vertices.add(_UpperCAmelCase )
        for edge in edges.copy():
            if from_node in edge or to_node in edge:
                edges.discard(_UpperCAmelCase )
    return chosen_vertices


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     set:
    lowerCamelCase__    :      Union[str, Any]					 =		set()
    for from_node, to_nodes in graph.items():
        for to_node in to_nodes:
            edges.add((from_node, to_node) )
    return edges


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    # graph = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]}
    # print(f"Matching vertex cover:\n{matching_min_vertex_cover(graph)}")





