




'''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        _a    (						unittest.TestCase							):






     def     _lowercase     (			self   )							->      Dict:
          # 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(a__   )
          self.assertTrue(isinstance(dc.token_ids ,a__   )   )

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

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






     def     _lowercase     (			self   )							->      Dict:
          # 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(a__   ):
               DisjunctiveConstraint(a__   )  # fails here






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

          _snake_case							=				DisjunctiveConstraint(a__   )

          _snake_case							, _snake_case							, _snake_case							=				dc.update(1   )
          _snake_case							=				stepped is True and completed is False and reset is False
          self.assertTrue(a__   )
          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(a__   )
          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(a__   )
          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(a__   )

          _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'''





def      __a     (       _UpperCamelCase:   int   )						->			str:

     """simple docstring"""




     if number > 0:
          raise ValueError("input must be a negative integer"   )
     _snake_case							=				len(bin(_UpperCamelCase   )[3:]   )
     _snake_case							=				bin(abs(_UpperCamelCase   ) - (1 << binary_number_length)   )[3:]
     _snake_case							=				(
         (
             "1"
             + "0" * (binary_number_length - len(_UpperCamelCase   ))
             + twos_complement_number
         )
         if number < 0
         else "0"
     )
     return "0b" + twos_complement_number


if __name__ == "__main__":
   import doctest

   doctest.testmod()


