






'''simple docstring'''


from typing import TYPE_CHECKING

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


lowerCamelCase_					:			Tuple     						=				{
    '''configuration_utils''': ['''GenerationConfig'''],
    '''streamers''': ['''TextIteratorStreamer''', '''TextStreamer'''],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_					:			int     						=				[
					    '''Constraint''',
					    '''ConstraintListState''',
					    '''DisjunctiveConstraint''',
					    '''PhrasalConstraint''',
					]
					lowerCamelCase_					:			Dict     						=				[
					    '''BeamHypotheses''',
					    '''BeamScorer''',
					    '''BeamSearchScorer''',
					    '''ConstrainedBeamSearchScorer''',
					]
					lowerCamelCase_					:			str     						=				[
					    '''EpsilonLogitsWarper''',
					    '''EtaLogitsWarper''',
					    '''ForcedBOSTokenLogitsProcessor''',
					    '''ForcedEOSTokenLogitsProcessor''',
					    '''HammingDiversityLogitsProcessor''',
					    '''InfNanRemoveLogitsProcessor''',
					    '''LogitsProcessor''',
					    '''LogitsProcessorList''',
					    '''LogitsWarper''',
					    '''MinLengthLogitsProcessor''',
					    '''MinNewTokensLengthLogitsProcessor''',
					    '''NoBadWordsLogitsProcessor''',
					    '''NoRepeatNGramLogitsProcessor''',
					    '''PrefixConstrainedLogitsProcessor''',
					    '''RepetitionPenaltyLogitsProcessor''',
					    '''SequenceBiasLogitsProcessor''',
					    '''EncoderRepetitionPenaltyLogitsProcessor''',
					    '''TemperatureLogitsWarper''',
					    '''TopKLogitsWarper''',
					    '''TopPLogitsWarper''',
					    '''TypicalLogitsWarper''',
					    '''EncoderNoRepeatNGramLogitsProcessor''',
					    '''ExponentialDecayLengthPenalty''',
					    '''LogitNormalization''',
					]
					lowerCamelCase_					:			Any     						=				[
					    '''MaxNewTokensCriteria''',
					    '''MaxLengthCriteria''',
					    '''MaxTimeCriteria''',
					    '''StoppingCriteria''',
					    '''StoppingCriteriaList''',
					    '''validate_stopping_criteria''',
					]
					lowerCamelCase_					:			Any     						=				[
					    '''GenerationMixin''',
					    '''top_k_top_p_filtering''',
					    '''GreedySearchEncoderDecoderOutput''',
					    '''GreedySearchDecoderOnlyOutput''',
					    '''SampleEncoderDecoderOutput''',
					    '''SampleDecoderOnlyOutput''',
					    '''BeamSearchEncoderDecoderOutput''',
					    '''BeamSearchDecoderOnlyOutput''',
					    '''BeamSampleEncoderDecoderOutput''',
					    '''BeamSampleDecoderOnlyOutput''',
					    '''ContrastiveSearchEncoderDecoderOutput''',
					    '''ContrastiveSearchDecoderOnlyOutput''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_					:			Union[str, Any]     						=				[
					    '''TFForcedBOSTokenLogitsProcessor''',
					    '''TFForcedEOSTokenLogitsProcessor''',
					    '''TFLogitsProcessor''',
					    '''TFLogitsProcessorList''',
					    '''TFLogitsWarper''',
					    '''TFMinLengthLogitsProcessor''',
					    '''TFNoBadWordsLogitsProcessor''',
					    '''TFNoRepeatNGramLogitsProcessor''',
					    '''TFRepetitionPenaltyLogitsProcessor''',
					    '''TFTemperatureLogitsWarper''',
					    '''TFTopKLogitsWarper''',
					    '''TFTopPLogitsWarper''',
					    '''TFForceTokensLogitsProcessor''',
					    '''TFSuppressTokensAtBeginLogitsProcessor''',
					    '''TFSuppressTokensLogitsProcessor''',
					]
					lowerCamelCase_					:			str     						=				[
					    '''TFGenerationMixin''',
					    '''tf_top_k_top_p_filtering''',
					    '''TFGreedySearchDecoderOnlyOutput''',
					    '''TFGreedySearchEncoderDecoderOutput''',
					    '''TFSampleEncoderDecoderOutput''',
					    '''TFSampleDecoderOnlyOutput''',
					    '''TFBeamSearchEncoderDecoderOutput''',
					    '''TFBeamSearchDecoderOnlyOutput''',
					    '''TFBeamSampleEncoderDecoderOutput''',
					    '''TFBeamSampleDecoderOnlyOutput''',
					    '''TFContrastiveSearchEncoderDecoderOutput''',
					    '''TFContrastiveSearchDecoderOnlyOutput''',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowerCamelCase_					:			Union[str, Any]     						=				[
					    '''FlaxForcedBOSTokenLogitsProcessor''',
					    '''FlaxForcedEOSTokenLogitsProcessor''',
					    '''FlaxLogitsProcessor''',
					    '''FlaxLogitsProcessorList''',
					    '''FlaxLogitsWarper''',
					    '''FlaxMinLengthLogitsProcessor''',
					    '''FlaxTemperatureLogitsWarper''',
					    '''FlaxTopKLogitsWarper''',
					    '''FlaxTopPLogitsWarper''',
					]
					lowerCamelCase_					:			List[str]     						=				[
					    '''FlaxGenerationMixin''',
					    '''FlaxGreedySearchOutput''',
					    '''FlaxSampleOutput''',
					    '''FlaxBeamSearchOutput''',
					]

if TYPE_CHECKING:
					from .configuration_utils import GenerationConfig
					from .streamers import TextIteratorStreamer, TextStreamer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
										from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
										from .logits_process import (
										    EncoderNoRepeatNGramLogitsProcessor,
										    EncoderRepetitionPenaltyLogitsProcessor,
										    EpsilonLogitsWarper,
										    EtaLogitsWarper,
										    ExponentialDecayLengthPenalty,
										    ForcedBOSTokenLogitsProcessor,
										    ForcedEOSTokenLogitsProcessor,
										    HammingDiversityLogitsProcessor,
										    InfNanRemoveLogitsProcessor,
										    LogitNormalization,
										    LogitsProcessor,
										    LogitsProcessorList,
										    LogitsWarper,
										    MinLengthLogitsProcessor,
										    MinNewTokensLengthLogitsProcessor,
										    NoBadWordsLogitsProcessor,
										    NoRepeatNGramLogitsProcessor,
										    PrefixConstrainedLogitsProcessor,
										    RepetitionPenaltyLogitsProcessor,
										    SequenceBiasLogitsProcessor,
										    TemperatureLogitsWarper,
										    TopKLogitsWarper,
										    TopPLogitsWarper,
										    TypicalLogitsWarper,
										)
										from .stopping_criteria import (
										    MaxLengthCriteria,
										    MaxNewTokensCriteria,
										    MaxTimeCriteria,
										    StoppingCriteria,
										    StoppingCriteriaList,
										    validate_stopping_criteria,
										)
										from .utils import (
										    BeamSampleDecoderOnlyOutput,
										    BeamSampleEncoderDecoderOutput,
										    BeamSearchDecoderOnlyOutput,
										    BeamSearchEncoderDecoderOutput,
										    ContrastiveSearchDecoderOnlyOutput,
										    ContrastiveSearchEncoderDecoderOutput,
										    GenerationMixin,
										    GreedySearchDecoderOnlyOutput,
										    GreedySearchEncoderDecoderOutput,
										    SampleDecoderOnlyOutput,
										    SampleEncoderDecoderOutput,
										    top_k_top_p_filtering,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tf_logits_process import (
										    TFForcedBOSTokenLogitsProcessor,
										    TFForcedEOSTokenLogitsProcessor,
										    TFForceTokensLogitsProcessor,
										    TFLogitsProcessor,
										    TFLogitsProcessorList,
										    TFLogitsWarper,
										    TFMinLengthLogitsProcessor,
										    TFNoBadWordsLogitsProcessor,
										    TFNoRepeatNGramLogitsProcessor,
										    TFRepetitionPenaltyLogitsProcessor,
										    TFSuppressTokensAtBeginLogitsProcessor,
										    TFSuppressTokensLogitsProcessor,
										    TFTemperatureLogitsWarper,
										    TFTopKLogitsWarper,
										    TFTopPLogitsWarper,
										)
										from .tf_utils import (
										    TFBeamSampleDecoderOnlyOutput,
										    TFBeamSampleEncoderDecoderOutput,
										    TFBeamSearchDecoderOnlyOutput,
										    TFBeamSearchEncoderDecoderOutput,
										    TFContrastiveSearchDecoderOnlyOutput,
										    TFContrastiveSearchEncoderDecoderOutput,
										    TFGenerationMixin,
										    TFGreedySearchDecoderOnlyOutput,
										    TFGreedySearchEncoderDecoderOutput,
										    TFSampleDecoderOnlyOutput,
										    TFSampleEncoderDecoderOutput,
										    tf_top_k_top_p_filtering,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .flax_logits_process import (
										    FlaxForcedBOSTokenLogitsProcessor,
										    FlaxForcedEOSTokenLogitsProcessor,
										    FlaxLogitsProcessor,
										    FlaxLogitsProcessorList,
										    FlaxLogitsWarper,
										    FlaxMinLengthLogitsProcessor,
										    FlaxTemperatureLogitsWarper,
										    FlaxTopKLogitsWarper,
										    FlaxTopPLogitsWarper,
										)
										from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
					import sys

					lowerCamelCase_					:			int     						=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)








'''simple docstring'''


lowerCamelCase_					:			List[Any]     						=				{0: [1, 2], 1: [0, 3], 2: [0], 3: [1], 4: [5, 6], 5: [4, 6], 6: [4, 5]}

lowerCamelCase_					:			Tuple     						=				{0: [1, 2, 3], 1: [0, 3], 2: [0], 3: [0, 1], 4: [], 5: []}







def 						__magic_name__(			_A    ,   _A    ,   _A       ):
						'''simple docstring'''





						UpperCamelCase__       =			True
						UpperCamelCase__       =			[]

						for neighbour in graph[vert]:
												if not visited[neighbour]:
																		connected_verts += dfs(_A    ,   _A    ,   _A       )

						return [vert, *connected_verts]







def 						__magic_name__(			_A       ):
						'''simple docstring'''





						UpperCamelCase__       =			len(_A       )
						UpperCamelCase__       =			graph_size * [False]
						UpperCamelCase__       =			[]

						for i in range(_A       ):
												if not visited[i]:
																		UpperCamelCase__       =			dfs(_A    ,   _A    ,   _A       )
																		components_list.append(_A       )

						return components_list


if __name__ == "__main__":
					import doctest

					doctest.testmod()
