
'''simple docstring'''
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       _lowerCAmelCase   (   unittest.TestCase				):







							'''simple docstring'''

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

														_snake_case       =  [[1, 2, 4], [1, 2, 3, 4]]
														_snake_case       =  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 	lowercase							(self  )					->       str:
														# 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).
														_snake_case       =  [[1, 2], [1, 2, 3, 4]]

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

							def 	lowercase							(self  )					->       Tuple:
														_snake_case       =  [[1, 2, 3], [1, 2, 4]]

														_snake_case       =  DisjunctiveConstraint(UpperCAmelCase  )

														_snake_case,							_snake_case,							_snake_case       =  dc.update(1  )
														_snake_case       =  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]  )

														_snake_case,							_snake_case,							_snake_case       =  dc.update(2  )
														_snake_case       =  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]  )

														_snake_case,							_snake_case,							_snake_case       =  dc.update(3  )
														_snake_case       =  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 	lowercase							(self  )					->       Optional[Any]:
														_snake_case       =  [[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

														_snake_case       =  DisjunctiveConstraint(UpperCAmelCase  )

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

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

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

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

														dc.reset()

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

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

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

'''simple docstring'''
from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
				if not (is_transformers_available() and is_torch_available()):
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
				from .multicontrolnet import MultiControlNetModel
				from .pipeline_controlnet import StableDiffusionControlNetPipeline
				from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
				from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
				from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline