





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 tempfile import TemporaryDirectory
from unittest import TestCase
from unittest.mock import MagicMock, patch

from transformers import AutoModel, TFAutoModel
from transformers.onnx import FeaturesManager
from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch

@require_torch
@require_tf
class       __A     (						a    ):


				def _snake_case       (		self							):
								lowerCamelCase	 =SMALL_MODEL_IDENTIFIER
								lowerCamelCase	 ="""pt"""
								lowerCamelCase	 ="""tf"""


				def _snake_case       (		self   , UpperCAmelCase_							):
								lowerCamelCase	 =AutoModel.from_pretrained(self.test_model							)
								model_pt.save_pretrained(UpperCAmelCase_							)


				def _snake_case       (		self   , UpperCAmelCase_							):
								lowerCamelCase	 =TFAutoModel.from_pretrained(self.test_model   , from_pt=UpperCAmelCase_							)
								model_tf.save_pretrained(UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 ="""mock_framework"""

								# Framework provided - return whatever the user provides
								lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model   , UpperCAmelCase_							)
								self.assertEqual(UpperCAmelCase_   , UpperCAmelCase_							)

								# Local checkpoint and framework provided - return provided framework
								# PyTorch checkpoint
								with TemporaryDirectory() as local_pt_ckpt:
												self._setup_pt_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_   , UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , UpperCAmelCase_							)

								# TensorFlow checkpoint
								with TemporaryDirectory() as local_tf_ckpt:
												self._setup_tf_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_   , UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , UpperCAmelCase_							)


				def _snake_case       (		self							):
								# PyTorch checkpoint
								with TemporaryDirectory() as local_pt_ckpt:
												self._setup_pt_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , self.framework_pt							)

								# TensorFlow checkpoint
								with TemporaryDirectory() as local_tf_ckpt:
												self._setup_tf_ckpt(UpperCAmelCase_							)
												lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_							)
												self.assertEqual(UpperCAmelCase_   , self.framework_tf							)

								# Invalid local checkpoint
								with TemporaryDirectory() as local_invalid_ckpt:
												with self.assertRaises(UpperCAmelCase_							):
																lowerCamelCase	 =FeaturesManager.determine_framework(UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_tf_available"""   , UpperCAmelCase_							):
												lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)
												self.assertEqual(UpperCAmelCase_   , self.framework_pt							)

								# PyTorch not in environment -> use TensorFlow
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_torch_available"""   , UpperCAmelCase_							):
												lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)
												self.assertEqual(UpperCAmelCase_   , self.framework_tf							)

								# Both in environment -> use PyTorch
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_tf_available"""   , UpperCAmelCase_							), patch(
								    """transformers.onnx.features.is_torch_available"""   , UpperCAmelCase_							):
												lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)
												self.assertEqual(UpperCAmelCase_   , self.framework_pt							)

								# Both not in environment -> raise error
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								lowerCamelCase	 =MagicMock(return_value=UpperCAmelCase_							)
								with patch("""transformers.onnx.features.is_tf_available"""   , UpperCAmelCase_							), patch(
								    """transformers.onnx.features.is_torch_available"""   , UpperCAmelCase_							):
												with self.assertRaises(UpperCAmelCase_							):
																lowerCamelCase	 =FeaturesManager.determine_framework(self.test_model							)





