
import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
		import os

		# The slow tests are often failing with OOM error on GPU
		# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
		# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
		lowercase        =  '''platform'''

		import jax
		import jax.numpy as jnp

		from transformers import BlenderbotTokenizer
		from transformers.models.blenderbot.modeling_flax_blenderbot import (
		    FlaxBlenderbotForConditionalGeneration,
		    FlaxBlenderbotModel,
		    shift_tokens_right,
		)



def      __lowerCAmelCase						(							UpperCAmelCase__				:      int			,				UpperCAmelCase__				:      Tuple			,				UpperCAmelCase__				:      str=None			,				UpperCAmelCase__				:      List[Any]=None			,				UpperCAmelCase__				:      Union[str, Any]=None			,				UpperCAmelCase__				:      Tuple=None			,				UpperCAmelCase__				:      Union[str, Any]=None			,				UpperCAmelCase__				:      Any=None			,				)  ->    Optional[Any]:
							if attention_mask is None:
														lowerCamelCase_							  =					np.where(input_ids != config.pad_token_id			,				1			,				0       )
							if decoder_attention_mask is None:
														lowerCamelCase_							  =					np.where(decoder_input_ids != config.pad_token_id			,				1			,				0       )
							if head_mask is None:
														lowerCamelCase_							  =					np.ones((config.encoder_layers, config.encoder_attention_heads)       )
							if decoder_head_mask is None:
														lowerCamelCase_							  =					np.ones((config.decoder_layers, config.decoder_attention_heads)       )
							if cross_attn_head_mask is None:
														lowerCamelCase_							  =					np.ones((config.decoder_layers, config.decoder_attention_heads)       )
							return {
							    "input_ids": input_ids,
							    "decoder_input_ids": decoder_input_ids,
							    "attention_mask": attention_mask,
							    "decoder_attention_mask": attention_mask,
							}





class       __A:

					def __init__(	self					:     List[Any]   ,					__UpperCamelCase					:     int   ,					__UpperCamelCase					:     Dict=1_3   ,					__UpperCamelCase					:     List[Any]=7   ,					__UpperCamelCase					:     Union[str, Any]=True   ,					__UpperCamelCase					:     Union[str, Any]=False   ,					__UpperCamelCase					:     int=9_9   ,					__UpperCamelCase					:     Tuple=1_6   ,					__UpperCamelCase					:     Any=2   ,					__UpperCamelCase					:     Any=4   ,					__UpperCamelCase					:     Optional[int]=4   ,					__UpperCamelCase					:     Tuple="gelu"   ,					__UpperCamelCase					:     int=0.1   ,					__UpperCamelCase					:     str=0.1   ,					__UpperCamelCase					:     List[Any]=3_2   ,					__UpperCamelCase					:     Optional[Any]=2   ,					__UpperCamelCase					:     Union[str, Any]=1   ,					__UpperCamelCase					:     List[str]=0   ,					__UpperCamelCase					:     int=0.02   ,					):
												lowerCamelCase_							  =					parent
												lowerCamelCase_							  =					batch_size
												lowerCamelCase_							  =					seq_length
												lowerCamelCase_							  =					is_training
												lowerCamelCase_							  =					use_labels
												lowerCamelCase_							  =					vocab_size
												lowerCamelCase_							  =					hidden_size
												lowerCamelCase_							  =					num_hidden_layers
												lowerCamelCase_							  =					num_attention_heads
												lowerCamelCase_							  =					intermediate_size
												lowerCamelCase_							  =					hidden_act
												lowerCamelCase_							  =					hidden_dropout_prob
												lowerCamelCase_							  =					attention_probs_dropout_prob
												lowerCamelCase_							  =					max_position_embeddings
												lowerCamelCase_							  =					eos_token_id
												lowerCamelCase_							  =					pad_token_id
												lowerCamelCase_							  =					bos_token_id
												lowerCamelCase_							  =					initializer_range

					def    lowercase__      (	self					:     List[Any]   ):
												lowerCamelCase_							  =					np.clip(ids_tensor([self.batch_size, self.seq_length - 1]   ,					self.vocab_size   )   ,					3   ,					self.vocab_size   )
												lowerCamelCase_							  =					np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)   ,					dtype=np.intaa   ))   ,					-1   )

												lowerCamelCase_							  =					shift_tokens_right(__UpperCamelCase   ,					1   ,					2   )

												lowerCamelCase_							  =					BlenderbotConfig(
												    vocab_size=self.vocab_size   ,					d_model=self.hidden_size   ,					encoder_layers=self.num_hidden_layers   ,					decoder_layers=self.num_hidden_layers   ,					encoder_attention_heads=self.num_attention_heads   ,					decoder_attention_heads=self.num_attention_heads   ,					encoder_ffn_dim=self.intermediate_size   ,					decoder_ffn_dim=self.intermediate_size   ,					dropout=self.hidden_dropout_prob   ,					attention_dropout=self.attention_probs_dropout_prob   ,					max_position_embeddings=self.max_position_embeddings   ,					eos_token_id=self.eos_token_id   ,					bos_token_id=self.bos_token_id   ,					pad_token_id=self.pad_token_id   ,					initializer_range=self.initializer_range   ,					use_cache=__UpperCamelCase   ,					)
												lowerCamelCase_							  =					prepare_blenderbot_inputs_dict(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   )
												return config, inputs_dict

					def    lowercase__      (	self					:     str   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.prepare_config_and_inputs()
												return config, inputs_dict

					def    lowercase__      (	self					:     Any   ,					__UpperCamelCase					:     Union[str, Any]   ,					__UpperCamelCase					:     Tuple   ,					__UpperCamelCase					:     Tuple   ):
												lowerCamelCase_							  =					2_0
												lowerCamelCase_							  =					model_class_name(__UpperCamelCase   )

												lowerCamelCase_							  =					model.encode(inputs_dict["""input_ids"""]   )

												lowerCamelCase_  ,   lowerCamelCase_							  =					(
												    inputs_dict["""decoder_input_ids"""],
												    inputs_dict["""decoder_attention_mask"""],
												)

												lowerCamelCase_							  =					model.init_cache(decoder_input_ids.shape[0]   ,					__UpperCamelCase   ,					__UpperCamelCase   )
												lowerCamelCase_							  =					jnp.ones((decoder_input_ids.shape[0], max_decoder_length)   ,					dtype="""i4"""   )

												lowerCamelCase_							  =					jnp.broadcast_to(
												    jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]   ,					(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)   ,					)
												lowerCamelCase_							  =					model.decode(
												    decoder_input_ids[:, :-1]   ,					__UpperCamelCase   ,					decoder_attention_mask=__UpperCamelCase   ,					past_key_values=__UpperCamelCase   ,					decoder_position_ids=__UpperCamelCase   ,					)

												lowerCamelCase_							  =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   ,					dtype="""i4"""   )
												lowerCamelCase_							  =					model.decode(
												    decoder_input_ids[:, -1:]   ,					__UpperCamelCase   ,					decoder_attention_mask=__UpperCamelCase   ,					past_key_values=outputs_cache.past_key_values   ,					decoder_position_ids=__UpperCamelCase   ,					)

												lowerCamelCase_							  =					model.decode(__UpperCamelCase   ,					__UpperCamelCase   )

												lowerCamelCase_							  =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
												self.parent.assertTrue(diff < 1E-3   ,					msg=F'''Max diff is {diff}'''   )



					def    lowercase__      (	self					:     Optional[Any]   ,					__UpperCamelCase					:     str   ,					__UpperCamelCase					:     Tuple   ,					__UpperCamelCase					:     Any   ):
												lowerCamelCase_							  =					2_0
												lowerCamelCase_							  =					model_class_name(__UpperCamelCase   )

												lowerCamelCase_							  =					model.encode(inputs_dict["""input_ids"""]   )

												lowerCamelCase_  ,   lowerCamelCase_							  =					(
												    inputs_dict["""decoder_input_ids"""],
												    inputs_dict["""decoder_attention_mask"""],
												)

												lowerCamelCase_							  =					jnp.concatenate(
												    [
												        decoder_attention_mask,
												        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])   ),
												    ]   ,					axis=-1   ,					)

												lowerCamelCase_							  =					model.init_cache(decoder_input_ids.shape[0]   ,					__UpperCamelCase   ,					__UpperCamelCase   )
												lowerCamelCase_							  =					jnp.broadcast_to(
												    jnp.arange(decoder_input_ids.shape[-1] - 1   )[None, :]   ,					(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)   ,					)

												lowerCamelCase_							  =					model.decode(
												    decoder_input_ids[:, :-1]   ,					__UpperCamelCase   ,					decoder_attention_mask=__UpperCamelCase   ,					past_key_values=__UpperCamelCase   ,					decoder_position_ids=__UpperCamelCase   ,					)
												lowerCamelCase_							  =					jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]   ,					dtype="""i4"""   )
												lowerCamelCase_							  =					model.decode(
												    decoder_input_ids[:, -1:]   ,					__UpperCamelCase   ,					past_key_values=outputs_cache.past_key_values   ,					decoder_attention_mask=__UpperCamelCase   ,					decoder_position_ids=__UpperCamelCase   ,					)

												lowerCamelCase_							  =					model.decode(__UpperCamelCase   ,					__UpperCamelCase   ,					decoder_attention_mask=__UpperCamelCase   )

												lowerCamelCase_							  =					np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])   )   )
												self.parent.assertTrue(diff < 1E-3   ,					msg=F'''Max diff is {diff}'''   )





@require_flax
class       __A(				unittest.TestCase       ):
					SCREAMING_SNAKE_CASE			    =    9_9

					def    lowercase__      (	self					:     Any   ):
												lowerCamelCase_							  =					np.array(
												    [
												        [7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2],
												        [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2],
												        [5, 9_7, 1_7, 3_9, 9_4, 4_0, 2],
												        [7_6, 8_3, 9_4, 2_5, 7_0, 7_8, 2],
												        [8_7, 5_9, 4_1, 3_5, 4_8, 6_6, 2],
												        [5_5, 1_3, 1_6, 5_8, 5, 2, 1],  # note padding
												        [6_4, 2_7, 3_1, 5_1, 1_2, 7_5, 2],
												        [5_2, 6_4, 8_6, 1_7, 8_3, 3_9, 2],
												        [4_8, 6_1, 9, 2_4, 7_1, 8_2, 2],
												        [2_6, 1, 6_0, 4_8, 2_2, 1_3, 2],
												        [2_1, 5, 6_2, 2_8, 1_4, 7_6, 2],
												        [4_5, 9_8, 3_7, 8_6, 5_9, 4_8, 2],
												        [7_0, 7_0, 5_0, 9, 2_8, 0, 2],
												    ]   ,					dtype=np.intaa   ,					)

												lowerCamelCase_							  =					input_ids.shape[0]
												lowerCamelCase_							  =					BlenderbotConfig(
												    vocab_size=self.vocab_size   ,					d_model=2_4   ,					encoder_layers=2   ,					decoder_layers=2   ,					encoder_attention_heads=2   ,					decoder_attention_heads=2   ,					encoder_ffn_dim=3_2   ,					decoder_ffn_dim=3_2   ,					max_position_embeddings=4_8   ,					eos_token_id=2   ,					pad_token_id=1   ,					bos_token_id=0   ,					)
												return config, input_ids, batch_size

					def    lowercase__      (	self					:     Tuple   ):
												lowerCamelCase_  ,   lowerCamelCase_  ,   lowerCamelCase_							  =					self._get_config_and_data()
												lowerCamelCase_							  =					FlaxBlenderbotForConditionalGeneration(__UpperCamelCase   )
												lowerCamelCase_							  =					lm_model(input_ids=__UpperCamelCase   )
												lowerCamelCase_							  =					(batch_size, input_ids.shape[1], config.vocab_size)
												self.assertEqual(outputs["""logits"""].shape   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     List[str]   ):
												lowerCamelCase_							  =					BlenderbotConfig(
												    vocab_size=self.vocab_size   ,					d_model=1_4   ,					encoder_layers=2   ,					decoder_layers=2   ,					encoder_attention_heads=2   ,					decoder_attention_heads=2   ,					encoder_ffn_dim=8   ,					decoder_ffn_dim=8   ,					max_position_embeddings=4_8   ,					)
												lowerCamelCase_							  =					FlaxBlenderbotForConditionalGeneration(__UpperCamelCase   )
												lowerCamelCase_							  =					np.array([[7_1, 8_2, 1_8, 3_3, 4_6, 9_1, 2], [6_8, 3_4, 2_6, 5_8, 3_0, 2, 1]]   ,					dtype=np.intaa   )
												lowerCamelCase_							  =					np.array([[8_2, 7_1, 8_2, 1_8, 2], [5_8, 6_8, 2, 1, 1]]   ,					dtype=np.intaa   )
												lowerCamelCase_							  =					lm_model(input_ids=__UpperCamelCase   ,					decoder_input_ids=__UpperCamelCase   )
												lowerCamelCase_							  =					(*summary.shape, config.vocab_size)
												self.assertEqual(outputs["""logits"""].shape   ,					__UpperCamelCase   )



					def    lowercase__      (	self					:     Any   ):
												lowerCamelCase_							  =					np.array([[7_1, 8_2, 1_8, 3_3, 2, 1, 1], [6_8, 3_4, 2_6, 5_8, 3_0, 8_2, 2]]   ,					dtype=np.intaa   )
												lowerCamelCase_							  =					shift_tokens_right(__UpperCamelCase   ,					1   ,					2   )
												lowerCamelCase_							  =					np.equal(__UpperCamelCase   ,					1   ).astype(np.floataa   ).sum()
												lowerCamelCase_							  =					np.equal(__UpperCamelCase   ,					1   ).astype(np.floataa   ).sum()
												self.assertEqual(shifted.shape   ,					input_ids.shape   )
												self.assertEqual(__UpperCamelCase   ,					n_pad_before - 1   )
												self.assertTrue(np.equal(shifted[:, 0]   ,					2   ).all()   )





@require_flax
class       __A(				UpperCAmelCase     ,		unittest.TestCase     ,		UpperCAmelCase       ):
					SCREAMING_SNAKE_CASE			    =    True
					SCREAMING_SNAKE_CASE			    =    (
					    (
					        FlaxBlenderbotModel,
					        FlaxBlenderbotForConditionalGeneration,
					    )
					    if is_flax_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE			    =    (FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()

					def    lowercase__      (	self					:     Union[str, Any]   ):
												lowerCamelCase_							  =					FlaxBlenderbotModelTester(self   )

					def    lowercase__      (	self					:     int   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
												for model_class in self.all_model_classes:
																			self.model_tester.check_use_cache_forward(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     List[str]   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs()
												for model_class in self.all_model_classes:
																			self.model_tester.check_use_cache_forward_with_attn_mask(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     Optional[int]   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			with self.subTest(model_class.__name__   ):
																										lowerCamelCase_							  =					self._prepare_for_class(__UpperCamelCase   ,					__UpperCamelCase   )
																										lowerCamelCase_							  =					model_class(__UpperCamelCase   )

																										@jax.jit
																										def encode_jitted(__UpperCamelCase					:     List[str]   ,					__UpperCamelCase					:     Dict=None   ,					**__UpperCamelCase					:     Tuple   ):
																																	return model.encode(input_ids=__UpperCamelCase   ,					attention_mask=__UpperCamelCase   )

																										with self.subTest("""JIT Enabled"""   ):
																																	lowerCamelCase_							  =					encode_jitted(**__UpperCamelCase   ).to_tuple()

																										with self.subTest("""JIT Disabled"""   ):
																																	with jax.disable_jit():
																																								lowerCamelCase_							  =					encode_jitted(**__UpperCamelCase   ).to_tuple()

																										self.assertEqual(len(__UpperCamelCase   )   ,					len(__UpperCamelCase   )   )
																										for jitted_output, output in zip(__UpperCamelCase   ,					__UpperCamelCase   ):
																																	self.assertEqual(jitted_output.shape   ,					output.shape   )

					def    lowercase__      (	self					:     int   ):
												lowerCamelCase_  ,   lowerCamelCase_							  =					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			with self.subTest(model_class.__name__   ):
																										lowerCamelCase_							  =					model_class(__UpperCamelCase   )
																										lowerCamelCase_							  =					model.encode(inputs_dict["""input_ids"""]   ,					inputs_dict["""attention_mask"""]   )

																										lowerCamelCase_							  =					{
																										    """decoder_input_ids""": inputs_dict["""decoder_input_ids"""],
																										    """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""],
																										    """encoder_outputs""": encoder_outputs,
																										}

																										@jax.jit
																										def decode_jitted(__UpperCamelCase					:     Any   ,					__UpperCamelCase					:     Dict   ,					__UpperCamelCase					:     int   ):
																																	return model.decode(
																																	    decoder_input_ids=__UpperCamelCase   ,					decoder_attention_mask=__UpperCamelCase   ,					encoder_outputs=__UpperCamelCase   ,					)

																										with self.subTest("""JIT Enabled"""   ):
																																	lowerCamelCase_							  =					decode_jitted(**__UpperCamelCase   ).to_tuple()

																										with self.subTest("""JIT Disabled"""   ):
																																	with jax.disable_jit():
																																								lowerCamelCase_							  =					decode_jitted(**__UpperCamelCase   ).to_tuple()

																										self.assertEqual(len(__UpperCamelCase   )   ,					len(__UpperCamelCase   )   )
																										for jitted_output, output in zip(__UpperCamelCase   ,					__UpperCamelCase   ):
																																	self.assertEqual(jitted_output.shape   ,					output.shape   )

					@slow
					def    lowercase__      (	self					:     Optional[int]   ):
												for model_class_name in self.all_model_classes:
																			lowerCamelCase_							  =					model_class_name.from_pretrained("""facebook/blenderbot-400M-distill"""   )
																			# FlaxBlenderbotForSequenceClassification expects eos token in input_ids
																			lowerCamelCase_							  =					np.ones((1, 1)   ) * model.config.eos_token_id
																			lowerCamelCase_							  =					model(__UpperCamelCase   )
																			self.assertIsNotNone(__UpperCamelCase   )



					@unittest.skipUnless(jax_device != """cpu"""   ,					"""3B test too slow on CPU."""   )
					@slow
					def    lowercase__      (	self					:     Optional[Any]   ):
												lowerCamelCase_							  =					{"""num_beams""": 1, """early_stopping""": True, """min_length""": 1_5, """max_length""": 2_5}
												lowerCamelCase_							  =					{"""skip_special_tokens""": True, """clean_up_tokenization_spaces""": True}

												lowerCamelCase_							  =					FlaxBlenderbotForConditionalGeneration.from_pretrained("""facebook/blenderbot-3B"""   ,					from_pt=__UpperCamelCase   )
												lowerCamelCase_							  =					BlenderbotTokenizer.from_pretrained("""facebook/blenderbot-3B"""   )

												lowerCamelCase_							  =					["""Sam"""]
												lowerCamelCase_							  =					tokenizer(__UpperCamelCase   ,					return_tensors="""jax"""   )

												lowerCamelCase_							  =					model.generate(**__UpperCamelCase   ,					**__UpperCamelCase   )
												lowerCamelCase_							  =					"""Sam is a great name. It means \"sun\" in Gaelic."""

												lowerCamelCase_							  =					tokenizer.batch_decode(__UpperCamelCase   ,					**__UpperCamelCase   )
												assert generated_txt[0].strip() == tgt_text







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    lowercase__      (	self					:     Optional[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.

												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    lowercase__      (	self					:     List[Any]   ):
												# 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    lowercase__      (	self					:     Union[str, Any]   ):
												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    lowercase__      (	self					:     Tuple   ):
												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]   )





