





import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
							import torch

							from transformers.generation import DisjunctiveConstraint

@require_torch
class       __A     (						unittest.TestCase    ):


				def _snake_case       (		self							):
								# For consistency across different places the DisjunctiveConstraint is called,
								# dc.token_ids is a list of integers. It is also initialized only by integers.

								lowerCamelCase	 =[[1, 2, 4], [1, 2, 3, 4]]
								lowerCamelCase	 =DisjunctiveConstraint(UpperCAmelCase_							)
								self.assertTrue(isinstance(dc.token_ids   , UpperCAmelCase_							)							)

								with self.assertRaises(UpperCAmelCase_							):
												DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]]							)							)

								with self.assertRaises(UpperCAmelCase_							):
												DisjunctiveConstraint([torch.LongTensor([1, 2, 4]							), torch.LongTensor([1, 2, 3, 4, 5]							)]							)


				def _snake_case       (		self							):
								# We can't have constraints that are complete subsets of another. This leads to a preverse
								# interpretation of "constraint fulfillment": does generating [1,2,3] fulfill the constraint?
								# It would mean that it generated [1,2] which fulfills it, but it's in the middle of potentially
								# fulfilling [1,2,3,4]. If we believe that [1,2,3] does fulfill the constraint, then the algorithm
								# will necessarily never reach [1,2,3,4], giving users a false sense of control (better to just not allow it).
								lowerCamelCase	 =[[1, 2], [1, 2, 3, 4]]

								with self.assertRaises(UpperCAmelCase_							):
												DisjunctiveConstraint(UpperCAmelCase_							)  # fails here


				def _snake_case       (		self							):
								lowerCamelCase	 =[[1, 2, 3], [1, 2, 4]]

								lowerCamelCase	 =DisjunctiveConstraint(UpperCAmelCase_							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(1							)
								lowerCamelCase	 =stepped is True and completed is False and reset is False
								self.assertTrue(UpperCAmelCase_							)
								self.assertTrue(not dc.completed							)
								self.assertTrue(dc.current_seq == [1]							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(2							)
								lowerCamelCase	 =stepped is True and completed is False and reset is False
								self.assertTrue(UpperCAmelCase_							)
								self.assertTrue(not dc.completed							)
								self.assertTrue(dc.current_seq == [1, 2]							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(3							)
								lowerCamelCase	 =stepped is True and completed is True and reset is False
								self.assertTrue(UpperCAmelCase_							)
								self.assertTrue(dc.completed							)  # Completed!
								self.assertTrue(dc.current_seq == [1, 2, 3]							)


				def _snake_case       (		self							):
								lowerCamelCase	 =[[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

								lowerCamelCase	 =DisjunctiveConstraint(UpperCAmelCase_							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(1							)
								self.assertTrue(not dc.completed							)
								self.assertTrue(dc.current_seq == [1]							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(2							)
								self.assertTrue(not dc.completed							)
								self.assertTrue(dc.current_seq == [1, 2]							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(4							)
								self.assertTrue(not dc.completed							)
								self.assertTrue(dc.current_seq == [1, 2, 4]							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(5							)
								self.assertTrue(dc.completed							)  # Completed!
								self.assertTrue(dc.current_seq == [1, 2, 4, 5]							)

								dc.reset()

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(1							)
								self.assertTrue(not dc.completed							)
								self.assertTrue(dc.remaining() == 3							)
								self.assertTrue(dc.current_seq == [1]							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(2							)
								self.assertTrue(not dc.completed							)
								self.assertTrue(dc.remaining() == 2							)
								self.assertTrue(dc.current_seq == [1, 2]							)

								lowerCamelCase ,  lowerCamelCase ,  lowerCamelCase	 =dc.update(5							)
								self.assertTrue(dc.completed							)  # Completed!
								self.assertTrue(dc.remaining() == 0							)
								self.assertTrue(dc.current_seq == [1, 2, 5]							)












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCAmelCase__						:			List[Any]									={'''configuration_yolos''': ['''YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''YolosConfig''', '''YolosOnnxConfig''']}

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__						:			Dict									=['''YolosFeatureExtractor''']
							UpperCAmelCase__						:			List[Any]									=['''YolosImageProcessor''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__						:			Optional[Any]									=[
							    '''YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''YolosForObjectDetection''',
							    '''YolosModel''',
							    '''YolosPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_yolos import YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP, YolosConfig, YolosOnnxConfig

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .feature_extraction_yolos import YolosFeatureExtractor
														from .image_processing_yolos import YolosImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_yolos import (
														    YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST,
														    YolosForObjectDetection,
														    YolosModel,
														    YolosPreTrainedModel,
														)


else:
							import sys

							UpperCAmelCase__						:			Optional[Any]									=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





