





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


__UpperCAmelCase			:  Optional[int]										=				{
    'auto_factory': ['get_values'],
    'configuration_auto': ['ALL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'CONFIG_MAPPING', 'MODEL_NAMES_MAPPING', 'AutoConfig'],
    'feature_extraction_auto': ['FEATURE_EXTRACTOR_MAPPING', 'AutoFeatureExtractor'],
    'image_processing_auto': ['IMAGE_PROCESSOR_MAPPING', 'AutoImageProcessor'],
    'processing_auto': ['PROCESSOR_MAPPING', 'AutoProcessor'],
    'tokenization_auto': ['TOKENIZER_MAPPING', 'AutoTokenizer'],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase			:  Tuple										=				[
          'MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING',
          'MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING',
          'MODEL_FOR_AUDIO_XVECTOR_MAPPING',
          'MODEL_FOR_BACKBONE_MAPPING',
          'MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING',
          'MODEL_FOR_CAUSAL_LM_MAPPING',
          'MODEL_FOR_CTC_MAPPING',
          'MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING',
          'MODEL_FOR_DEPTH_ESTIMATION_MAPPING',
          'MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING',
          'MODEL_FOR_IMAGE_SEGMENTATION_MAPPING',
          'MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING',
          'MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING',
          'MODEL_FOR_MASKED_LM_MAPPING',
          'MODEL_FOR_MASK_GENERATION_MAPPING',
          'MODEL_FOR_MULTIPLE_CHOICE_MAPPING',
          'MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING',
          'MODEL_FOR_OBJECT_DETECTION_MAPPING',
          'MODEL_FOR_PRETRAINING_MAPPING',
          'MODEL_FOR_QUESTION_ANSWERING_MAPPING',
          'MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING',
          'MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING',
          'MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING',
          'MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING',
          'MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING',
          'MODEL_FOR_TEXT_ENCODING_MAPPING',
          'MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING',
          'MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING',
          'MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING',
          'MODEL_FOR_VISION_2_SEQ_MAPPING',
          'MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING',
          'MODEL_MAPPING',
          'MODEL_WITH_LM_HEAD_MAPPING',
          'MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING',
          'MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING',
          'AutoModel',
          'AutoBackbone',
          'AutoModelForAudioClassification',
          'AutoModelForAudioFrameClassification',
          'AutoModelForAudioXVector',
          'AutoModelForCausalLM',
          'AutoModelForCTC',
          'AutoModelForDepthEstimation',
          'AutoModelForImageClassification',
          'AutoModelForImageSegmentation',
          'AutoModelForInstanceSegmentation',
          'AutoModelForMaskGeneration',
          'AutoModelForTextEncoding',
          'AutoModelForMaskedImageModeling',
          'AutoModelForMaskedLM',
          'AutoModelForMultipleChoice',
          'AutoModelForNextSentencePrediction',
          'AutoModelForObjectDetection',
          'AutoModelForPreTraining',
          'AutoModelForQuestionAnswering',
          'AutoModelForSemanticSegmentation',
          'AutoModelForSeq2SeqLM',
          'AutoModelForSequenceClassification',
          'AutoModelForSpeechSeq2Seq',
          'AutoModelForTableQuestionAnswering',
          'AutoModelForTokenClassification',
          'AutoModelForUniversalSegmentation',
          'AutoModelForVideoClassification',
          'AutoModelForVision2Seq',
          'AutoModelForVisualQuestionAnswering',
          'AutoModelForDocumentQuestionAnswering',
          'AutoModelWithLMHead',
          'AutoModelForZeroShotImageClassification',
          'AutoModelForZeroShotObjectDetection',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase			:  Tuple										=				[
          'TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING',
          'TF_MODEL_FOR_CAUSAL_LM_MAPPING',
          'TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING',
          'TF_MODEL_FOR_MASK_GENERATION_MAPPING',
          'TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING',
          'TF_MODEL_FOR_MASKED_LM_MAPPING',
          'TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING',
          'TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING',
          'TF_MODEL_FOR_PRETRAINING_MAPPING',
          'TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING',
          'TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING',
          'TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING',
          'TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING',
          'TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING',
          'TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING',
          'TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING',
          'TF_MODEL_FOR_TEXT_ENCODING_MAPPING',
          'TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING',
          'TF_MODEL_FOR_VISION_2_SEQ_MAPPING',
          'TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING',
          'TF_MODEL_MAPPING',
          'TF_MODEL_WITH_LM_HEAD_MAPPING',
          'TFAutoModel',
          'TFAutoModelForAudioClassification',
          'TFAutoModelForCausalLM',
          'TFAutoModelForImageClassification',
          'TFAutoModelForMaskedImageModeling',
          'TFAutoModelForMaskedLM',
          'TFAutoModelForMaskGeneration',
          'TFAutoModelForMultipleChoice',
          'TFAutoModelForNextSentencePrediction',
          'TFAutoModelForPreTraining',
          'TFAutoModelForDocumentQuestionAnswering',
          'TFAutoModelForQuestionAnswering',
          'TFAutoModelForSemanticSegmentation',
          'TFAutoModelForSeq2SeqLM',
          'TFAutoModelForSequenceClassification',
          'TFAutoModelForSpeechSeq2Seq',
          'TFAutoModelForTableQuestionAnswering',
          'TFAutoModelForTextEncoding',
          'TFAutoModelForTokenClassification',
          'TFAutoModelForVision2Seq',
          'TFAutoModelForZeroShotImageClassification',
          'TFAutoModelWithLMHead',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase			:  Any										=				[
          'FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING',
          'FLAX_MODEL_FOR_CAUSAL_LM_MAPPING',
          'FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING',
          'FLAX_MODEL_FOR_MASKED_LM_MAPPING',
          'FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING',
          'FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING',
          'FLAX_MODEL_FOR_PRETRAINING_MAPPING',
          'FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING',
          'FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING',
          'FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING',
          'FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING',
          'FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING',
          'FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING',
          'FLAX_MODEL_MAPPING',
          'FlaxAutoModel',
          'FlaxAutoModelForCausalLM',
          'FlaxAutoModelForImageClassification',
          'FlaxAutoModelForMaskedLM',
          'FlaxAutoModelForMultipleChoice',
          'FlaxAutoModelForNextSentencePrediction',
          'FlaxAutoModelForPreTraining',
          'FlaxAutoModelForQuestionAnswering',
          'FlaxAutoModelForSeq2SeqLM',
          'FlaxAutoModelForSequenceClassification',
          'FlaxAutoModelForSpeechSeq2Seq',
          'FlaxAutoModelForTokenClassification',
          'FlaxAutoModelForVision2Seq',
      ]


if TYPE_CHECKING:
      from .auto_factory import get_values
      from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
      from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
      from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
      from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
      from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_auto import (
                MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
                MODEL_FOR_AUDIO_XVECTOR_MAPPING,
                MODEL_FOR_BACKBONE_MAPPING,
                MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
                MODEL_FOR_CAUSAL_LM_MAPPING,
                MODEL_FOR_CTC_MAPPING,
                MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
                MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
                MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
                MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
                MODEL_FOR_MASK_GENERATION_MAPPING,
                MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
                MODEL_FOR_MASKED_LM_MAPPING,
                MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                MODEL_FOR_OBJECT_DETECTION_MAPPING,
                MODEL_FOR_PRETRAINING_MAPPING,
                MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
                MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
                MODEL_FOR_TEXT_ENCODING_MAPPING,
                MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
                MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
                MODEL_FOR_VISION_2_SEQ_MAPPING,
                MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
                MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
                MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
                MODEL_MAPPING,
                MODEL_WITH_LM_HEAD_MAPPING,
                AutoBackbone,
                AutoModel,
                AutoModelForAudioClassification,
                AutoModelForAudioFrameClassification,
                AutoModelForAudioXVector,
                AutoModelForCausalLM,
                AutoModelForCTC,
                AutoModelForDepthEstimation,
                AutoModelForDocumentQuestionAnswering,
                AutoModelForImageClassification,
                AutoModelForImageSegmentation,
                AutoModelForInstanceSegmentation,
                AutoModelForMaskedImageModeling,
                AutoModelForMaskedLM,
                AutoModelForMaskGeneration,
                AutoModelForMultipleChoice,
                AutoModelForNextSentencePrediction,
                AutoModelForObjectDetection,
                AutoModelForPreTraining,
                AutoModelForQuestionAnswering,
                AutoModelForSemanticSegmentation,
                AutoModelForSeqaSeqLM,
                AutoModelForSequenceClassification,
                AutoModelForSpeechSeqaSeq,
                AutoModelForTableQuestionAnswering,
                AutoModelForTextEncoding,
                AutoModelForTokenClassification,
                AutoModelForUniversalSegmentation,
                AutoModelForVideoClassification,
                AutoModelForVisionaSeq,
                AutoModelForVisualQuestionAnswering,
                AutoModelForZeroShotImageClassification,
                AutoModelForZeroShotObjectDetection,
                AutoModelWithLMHead,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_auto import (
                TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                TF_MODEL_FOR_CAUSAL_LM_MAPPING,
                TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
                TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                TF_MODEL_FOR_MASK_GENERATION_MAPPING,
                TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
                TF_MODEL_FOR_MASKED_LM_MAPPING,
                TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                TF_MODEL_FOR_PRETRAINING_MAPPING,
                TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
                TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
                TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
                TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
                TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
                TF_MODEL_MAPPING,
                TF_MODEL_WITH_LM_HEAD_MAPPING,
                TFAutoModel,
                TFAutoModelForAudioClassification,
                TFAutoModelForCausalLM,
                TFAutoModelForDocumentQuestionAnswering,
                TFAutoModelForImageClassification,
                TFAutoModelForMaskedImageModeling,
                TFAutoModelForMaskedLM,
                TFAutoModelForMaskGeneration,
                TFAutoModelForMultipleChoice,
                TFAutoModelForNextSentencePrediction,
                TFAutoModelForPreTraining,
                TFAutoModelForQuestionAnswering,
                TFAutoModelForSemanticSegmentation,
                TFAutoModelForSeqaSeqLM,
                TFAutoModelForSequenceClassification,
                TFAutoModelForSpeechSeqaSeq,
                TFAutoModelForTableQuestionAnswering,
                TFAutoModelForTextEncoding,
                TFAutoModelForTokenClassification,
                TFAutoModelForVisionaSeq,
                TFAutoModelForZeroShotImageClassification,
                TFAutoModelWithLMHead,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_auto import (
                FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
                FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                FLAX_MODEL_FOR_MASKED_LM_MAPPING,
                FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                FLAX_MODEL_FOR_PRETRAINING_MAPPING,
                FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
                FLAX_MODEL_MAPPING,
                FlaxAutoModel,
                FlaxAutoModelForCausalLM,
                FlaxAutoModelForImageClassification,
                FlaxAutoModelForMaskedLM,
                FlaxAutoModelForMultipleChoice,
                FlaxAutoModelForNextSentencePrediction,
                FlaxAutoModelForPreTraining,
                FlaxAutoModelForQuestionAnswering,
                FlaxAutoModelForSeqaSeqLM,
                FlaxAutoModelForSequenceClassification,
                FlaxAutoModelForSpeechSeqaSeq,
                FlaxAutoModelForTokenClassification,
                FlaxAutoModelForVisionaSeq,
            )

else:
      import sys

      __UpperCAmelCase			:  str										=				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)








from __future__ import annotations

from queue import Queue


class 	UpperCamelCase__       :

						'''simple docstring'''



						def __init__(  self	)  ->None:
									UpperCAmelCase__		:dict[int, list[int]] 		=    {}


						def    A__       (  self	)  ->None:
									for i in self.vertices:
												print(A  , ' : '  , ' -> '.join([str(A	) for j in self.vertices[i]]	)	)


						def    A__       (  self  , A  , A	)  ->None:
									if from_vertex in self.vertices:
												self.vertices[from_vertex].append(A	)
									else:
												UpperCAmelCase__		:Union[str, Any] 		=    [to_vertex]


						def    A__       (  self  , A	)  ->set[int]:
									UpperCAmelCase__		:str 		=    set()

									# create a first in first out queue to store all the vertices for BFS
									UpperCAmelCase__		:Queue 		=    Queue()

									# mark the source node as visited and enqueue it
									visited.add(A	)
									queue.put(A	)

									while not queue.empty():
												UpperCAmelCase__		:List[str] 		=    queue.get()

												# loop through all adjacent vertex and enqueue it if not yet visited
												for adjacent_vertex in self.vertices[vertex]:
															if adjacent_vertex not in visited:
																		queue.put(A	)
																		visited.add(A	)
									return visited


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

						testmod(verbose=True)

						__snake_case					:							Any           =							Graph()
						g.add_edge(0, 1)
						g.add_edge(0, 2)
						g.add_edge(1, 2)
						g.add_edge(2, 0)
						g.add_edge(2, 3)
						g.add_edge(3, 3)

						g.print_graph()
						# 0  :  1 -> 2
						# 1  :  2
						# 2  :  0 -> 3
						# 3  :  3

						assert sorted(g.bfs(2)) == [0, 1, 2, 3]





