



import os
import tempfile
import unittest

from transformers import FlaubertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

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 (
       FlaubertForMultipleChoice,
       FlaubertForQuestionAnswering,
       FlaubertForQuestionAnsweringSimple,
       FlaubertForSequenceClassification,
       FlaubertForTokenClassification,
       FlaubertModel,
       FlaubertWithLMHeadModel,
   )
   from transformers.models.flaubert.modeling_flaubert import FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST



class      _UpperCAmelCase      (							A__  ):




     def __init__(					self			,    a__			,    a__=1_3			,    a__=7			,    a__=True			,    a__=True			,    a__=True			,    a__=True			,    a__=True			,    a__=False			,    a__=False			,    a__=False			,    a__=2			,    a__=9_9			,    a__=0			,    a__=3_2			,    a__=5			,    a__=4			,    a__=0.1			,    a__=0.1			,    a__=5_1_2			,    a__=1_2			,    a__=2			,    a__=0.0_2			,    a__=3			,    a__=4			,    a__="last"			,    a__=None			,    a__=None			,    ):
         A__					=       parent
         A__					=       batch_size
         A__					=       seq_length
         A__					=       is_training
         A__					=       use_input_lengths
         A__					=       use_token_type_ids
         A__					=       use_labels
         A__					=       gelu_activation
         A__					=       sinusoidal_embeddings
         A__					=       causal
         A__					=       asm
         A__					=       n_langs
         A__					=       vocab_size
         A__					=       n_special
         A__					=       hidden_size
         A__					=       num_hidden_layers
         A__					=       num_attention_heads
         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__					=       summary_type
         A__					=       use_proj
         A__					=       scope




     def 		snake_case_		(					self):
         A__					=       ids_tensor([self.batch_size, self.seq_length]			,    self.vocab_size)
         A__					=       random_attention_mask([self.batch_size, self.seq_length])

         A__					=       None
         if self.use_input_lengths:
             A__					=       (
                 ids_tensor([self.batch_size]			,    vocab_size=2) + self.seq_length - 2
             )  # small variation of seq_length

         A__					=       None
         if self.use_token_type_ids:
             A__					=       ids_tensor([self.batch_size, self.seq_length]			,    self.n_langs)

         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]			,    2).float()
             A__					=       ids_tensor([self.batch_size]			,    self.num_choices)

         A__					=       self.get_config()

         return (
             config,
             input_ids,
             token_type_ids,
             input_lengths,
             sequence_labels,
             token_labels,
             is_impossible_labels,
             choice_labels,
             input_mask,
         )




     def 		snake_case_		(					self):
         return FlaubertConfig(
             vocab_size=self.vocab_size			,    n_special=self.n_special			,    emb_dim=self.hidden_size			,    n_layers=self.num_hidden_layers			,    n_heads=self.num_attention_heads			,    dropout=self.hidden_dropout_prob			,    attention_dropout=self.attention_probs_dropout_prob			,    gelu_activation=self.gelu_activation			,    sinusoidal_embeddings=self.sinusoidal_embeddings			,    asm=self.asm			,    causal=self.causal			,    n_langs=self.n_langs			,    max_position_embeddings=self.max_position_embeddings			,    initializer_range=self.initializer_range			,    summary_type=self.summary_type			,    use_proj=self.use_proj			,    )




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    ):
         A__					=       FlaubertModel(config=a__)
         model.to(a__)
         model.eval()
         A__					=       model(a__			,    lengths=a__			,    langs=a__)
         A__					=       model(a__			,    langs=a__)
         A__					=       model(a__)
         self.parent.assertEqual(result.last_hidden_state.shape			,    (self.batch_size, self.seq_length, self.hidden_size))




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    ):
         A__					=       FlaubertWithLMHeadModel(a__)
         model.to(a__)
         model.eval()

         A__					=       model(a__			,    token_type_ids=a__			,    labels=a__)
         self.parent.assertEqual(result.loss.shape			,    ())
         self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.vocab_size))




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    ):
         A__					=       FlaubertForQuestionAnsweringSimple(a__)
         model.to(a__)
         model.eval()

         A__					=       model(a__)

         A__					=       model(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 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    ):
         A__					=       FlaubertForQuestionAnswering(a__)
         model.to(a__)
         model.eval()

         A__					=       model(a__)

         A__					=       model(
             a__			,    start_positions=a__			,    end_positions=a__			,    cls_index=a__			,    is_impossible=a__			,    p_mask=a__			,    )

         A__					=       model(
             a__			,    start_positions=a__			,    end_positions=a__			,    cls_index=a__			,    is_impossible=a__			,    )

         ((A__)			,						)					=       result_with_labels.to_tuple()

         A__					=       model(a__			,    start_positions=a__			,    end_positions=a__)

         ((A__)			,						)					=       result_with_labels.to_tuple()

         self.parent.assertEqual(result_with_labels.loss.shape			,    ())
         self.parent.assertEqual(result.start_top_log_probs.shape			,    (self.batch_size, model.config.start_n_top))
         self.parent.assertEqual(result.start_top_index.shape			,    (self.batch_size, model.config.start_n_top))
         self.parent.assertEqual(
             result.end_top_log_probs.shape			,    (self.batch_size, model.config.start_n_top * model.config.end_n_top))
         self.parent.assertEqual(
             result.end_top_index.shape			,    (self.batch_size, model.config.start_n_top * model.config.end_n_top))
         self.parent.assertEqual(result.cls_logits.shape			,    (self.batch_size,))




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    ):
         A__					=       FlaubertForSequenceClassification(a__)
         model.to(a__)
         model.eval()

         A__					=       model(a__)
         A__					=       model(a__			,    labels=a__)

         self.parent.assertEqual(result.loss.shape			,    ())
         self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.type_sequence_label_size))




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    ):
         A__					=       self.num_labels
         A__					=       FlaubertForTokenClassification(a__)
         model.to(a__)
         model.eval()

         A__					=       model(a__			,    attention_mask=a__			,    labels=a__)
         self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.num_labels))




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    a__			,    ):
         A__					=       self.num_choices
         A__					=       FlaubertForMultipleChoice(config=a__)
         model.to(a__)
         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(
             a__			,    attention_mask=a__			,    token_type_ids=a__			,    labels=a__			,    )
         self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_choices))




     def 		snake_case_		(					self):
         A__					=       self.prepare_config_and_inputs()
         (
             (
             A__
         )			,						(
             A__
         )			,						(
             A__
         )			,						(
             A__
         )			,						(
             A__
         )			,						(
             A__
         )			,						(
             A__
         )			,						(
             A__
         )			,						(
             A__
         )			,						
         )					=       config_and_inputs
         A__					=       {
             '''input_ids''': input_ids,
             '''token_type_ids''': token_type_ids,
             '''lengths''': input_lengths,
             '''attention_mask''': input_mask,
         }
         return config, inputs_dict







@require_torch
class      _UpperCAmelCase      (							A__      ,   A__      ,   unittest.TestCase  ):
     UpperCamelCase__		     =					(
         (
             FlaubertModel,
             FlaubertWithLMHeadModel,
             FlaubertForQuestionAnswering,
             FlaubertForQuestionAnsweringSimple,
             FlaubertForSequenceClassification,
             FlaubertForTokenClassification,
             FlaubertForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     UpperCamelCase__		     =					(
         {
             '''feature-extraction''': FlaubertModel,
             '''fill-mask''': FlaubertWithLMHeadModel,
             '''question-answering''': FlaubertForQuestionAnsweringSimple,
             '''text-classification''': FlaubertForSequenceClassification,
             '''token-classification''': FlaubertForTokenClassification,
             '''zero-shot''': FlaubertForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )




     def 		snake_case_		(					self			,    a__			,    a__			,    a__			,    a__			,    a__):
         if (
             pipeline_test_casse_name == "QAPipelineTests"
             and tokenizer_name is not None
             and not tokenizer_name.endswith('''Fast''')
         ):
             # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
             # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
             # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
             return True

         return False




     def 		snake_case_		(					self			,    a__			,    a__			,    a__=False):
         A__					=       super()._prepare_for_class(a__			,    a__			,    return_labels=a__)

         if return_labels:
             if model_class.__name__ == "FlaubertForQuestionAnswering":
                 A__					=       torch.zeros(
                     self.model_tester.batch_size			,    dtype=torch.long			,    device=a__)
                 A__					=       torch.zeros(
                     self.model_tester.batch_size			,    dtype=torch.long			,    device=a__)

         return inputs_dict




     def 		snake_case_		(					self):
         A__					=       FlaubertModelTester(self)
         A__					=       ConfigTester(self			,    config_class=a__			,    emb_dim=3_7)




     def 		snake_case_		(					self):
         self.config_tester.run_common_tests()




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_model(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_lm_head(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_simple_qa(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_qa(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_sequence_classif(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_token_classif(*a__)




     def 		snake_case_		(					self):
         A__					=       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_flaubert_multiple_choice(*a__)




     @slow
     def 		snake_case_		(					self):
         for model_name in FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             A__					=       FlaubertModel.from_pretrained(a__)
             self.assertIsNotNone(a__)




     @slow
     @require_torch_gpu
     def 		snake_case_		(					self):
         A__			,						A__					=       self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes:
             # FlauBertForMultipleChoice behaves incorrectly in JIT environments.
             if model_class == FlaubertForMultipleChoice:
                 return

             A__					=       True
             A__					=       model_class(config=a__)

             A__					=       self._prepare_for_class(a__			,    a__)
             A__					=       torch.jit.trace(
                 a__			,    (inputs_dict['''input_ids'''].to('''cpu'''), inputs_dict['''attention_mask'''].to('''cpu''')))

             with tempfile.TemporaryDirectory() as tmp:
                 torch.jit.save(a__			,    os.path.join(a__			,    '''traced_model.pt'''))
                 A__					=       torch.jit.load(os.path.join(a__			,    '''traced_model.pt''')			,    map_location=a__)
                 loaded(inputs_dict['''input_ids'''].to(a__)			,    inputs_dict['''attention_mask'''].to(a__))







@require_torch
class      _UpperCAmelCase      (							unittest.TestCase  ):




     @slow
     def 		snake_case_		(					self):
         A__					=       FlaubertModel.from_pretrained('''flaubert/flaubert_base_cased''')
         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]])
         with torch.no_grad():
             A__					=       model(a__)[0]
         A__					=       torch.Size((1, 1_1, 7_6_8))
         self.assertEqual(output.shape			,    a__)
         A__					=       torch.tensor(
             [[[-2.6_2_5_1, -1.4_2_9_8, -0.0_2_2_7], [-2.8_5_1_0, -1.6_3_8_7, 0.2_2_5_8], [-2.8_1_1_4, -1.1_8_3_2, -0.3_0_6_6]]])

         self.assertTrue(torch.allclose(output[:, :3, :3]			,    a__			,    atol=1e-4))





from __future__ import annotations



def 		lowerCAmelCase__     (       UpperCamelCase_					:							dict			,							UpperCamelCase_					:							str						)->	set[str]:
    A__			,						A__					=       set(UpperCamelCase_						), [start]

    while stack:
        A__					=       stack.pop()
        explored.add(UpperCamelCase_						)
        # Differences from BFS:
        # 1) pop last element instead of first one
        # 2) add adjacent elements to stack without exploring them
        for adj in reversed(graph[v]						):
            if adj not in explored:
                stack.append(UpperCamelCase_						)
    return explored


_lowercase    	=		{
    "A": ["B", "C", "D"],
    "B": ["A", "D", "E"],
    "C": ["A", "F"],
    "D": ["B", "D"],
    "E": ["B", "F"],
    "F": ["C", "E", "G"],
    "G": ["F"],
}

if __name__ == "__main__":
   import doctest

   doctest.testmod()
   print(depth_first_search(G, "A"))
