






'''simple docstring'''



import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar
class 				__SCREAMING_SNAKE_CASE							(				unittest.TestCase  ):




      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         __a					  =     logging.get_logger()

         # the current default level is logging.WARNING
         __a					  =     logging.get_verbosity()

         logging.set_verbosity_error()
         self.assertEqual(logger.getEffectiveLevel()			, logging.get_verbosity()   )

         logging.set_verbosity_warning()
         self.assertEqual(logger.getEffectiveLevel()			, logging.get_verbosity()   )

         logging.set_verbosity_info()
         self.assertEqual(logger.getEffectiveLevel()			, logging.get_verbosity()   )

         logging.set_verbosity_debug()
         self.assertEqual(logger.getEffectiveLevel()			, logging.get_verbosity()   )

         # restore to the original level
         logging.set_verbosity(lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->Optional[int]:



         '''simple docstring'''
         __a					  =     logging.get_verbosity()

         __a					  =     logging.get_logger('transformers.models.bart.tokenization_bart'   )
         __a					  =     'Testing 1, 2, 3'

         # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
         if level_origin <= logging.WARNING:
            with CaptureLogger(lowerCamelCase   ) as cl:
               logger.warning(lowerCamelCase   )
            self.assertEqual(cl.out			, msg + '\n'   )

         # this is setting the level for all of `transformers.*` loggers
         logging.set_verbosity_error()

         # should not be able to log warnings
         with CaptureLogger(lowerCamelCase   ) as cl:
            logger.warning(lowerCamelCase   )
         self.assertEqual(cl.out			, ''   )

         # should be able to log warnings again
         logging.set_verbosity_warning()
         with CaptureLogger(lowerCamelCase   ) as cl:
            logger.warning(lowerCamelCase   )
         self.assertEqual(cl.out			, msg + '\n'   )

         # restore to the original level
         logging.set_verbosity(lowerCamelCase   )




      @mockenv(TRANSFORMERS_VERBOSITY='error'   )
      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         # reset for the env var to take effect, next time some logger call is made
         transformers.utils.logging._reset_library_root_logger()
         # this action activates the env var
         __a					  =     logging.get_logger('transformers.models.bart.tokenization_bart'   )

         __a					  =     os.getenv('TRANSFORMERS_VERBOSITY'			, lowerCamelCase   )
         __a					  =     logging.log_levels[env_level_str]

         __a					  =     logging.get_verbosity()
         self.assertEqual(
             lowerCamelCase			, lowerCamelCase			, F"""TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}"""			, )

         # restore to the original level
         __a					  =     ''
         transformers.utils.logging._reset_library_root_logger()




      @mockenv(TRANSFORMERS_VERBOSITY='super-error'   )
      def 			__UpperCamelCase				(	self   )				->Dict:



         '''simple docstring'''
         # reset for the env var to take effect, next time some logger call is made
         transformers.utils.logging._reset_library_root_logger()
         __a					  =     logging.logging.getLogger()
         with CaptureLogger(lowerCamelCase   ) as cl:
            # this action activates the env var
            logging.get_logger('transformers.models.bart.tokenization_bart'   )
         self.assertIn('Unknown option TRANSFORMERS_VERBOSITY=super-error'			, cl.out   )

         # no need to restore as nothing was changed






      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         # testing `logger.warning_advice()`
         transformers.utils.logging._reset_library_root_logger()

         __a					  =     logging.get_logger('transformers.models.bart.tokenization_bart'   )
         __a					  =     'Testing 1, 2, 3'

         with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='1'   ):
            # nothing should be logged as env var disables this method
            with CaptureLogger(lowerCamelCase   ) as cl:
               logger.warning_advice(lowerCamelCase   )
            self.assertEqual(cl.out			, ''   )

         with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=''   ):
            # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
            with CaptureLogger(lowerCamelCase   ) as cl:
               logger.warning_advice(lowerCamelCase   )
            self.assertEqual(cl.out			, msg + '\n'   )







def  __UpperCAmelCase						(					)	->      int:

   """simple docstring"""
   disable_progress_bar()
   assert are_progress_bars_disabled()

   enable_progress_bar()
   assert not are_progress_bars_disabled()







'''simple docstring'''



from timeit import timeit

__UpperCamelCase   :							int         =   {
    """MALAYALAM""": True,
    """String""": False,
    """rotor""": True,
    """level""": True,
    """A""": True,
    """BB""": True,
    """ABC""": False,
    """amanaplanacanalpanama""": True,  # "a man a plan a canal panama"
}
# Ensure our test data is valid
assert all((key == key[::-1]) is value for key, value in test_data.items())



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      bool:

   """simple docstring"""
   __a					  =     0
   __a					  =     len(SCREAMING_SNAKE_CASE__     ) - 1
   while start_i < end_i:
      if s[start_i] == s[end_i]:
         start_i += 1
         end_i -= 1
      else:
         return False
   return True



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      bool:

   """simple docstring"""
   __a					  =     len(SCREAMING_SNAKE_CASE__     ) // 2
   __a					  =     len(SCREAMING_SNAKE_CASE__     )

   # We need to traverse till half of the length of string
   # as we can get access of the i'th last element from
   # i'th index.
   # eg: [0,1,2,3,4,5] => 4th index can be accessed
   # with the help of 1st index (i==n-i-1)
   # where n is length of string
   return all(s[i] == s[n - i - 1] for i in range(SCREAMING_SNAKE_CASE__     )     )



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      bool:

   """simple docstring"""
   if len(SCREAMING_SNAKE_CASE__     ) <= 2:
      return True
   if s[0] == s[len(SCREAMING_SNAKE_CASE__     ) - 1]:
      return is_palindrome_recursive(s[1:-1]     )
   else:
      return False



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      bool:

   """simple docstring"""
   return s == s[::-1]



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						str     )	->      None:

   """simple docstring"""
   __a					  =     f"""all({name}(key) is value for key, value in test_data.items())"""
   __a					  =     f"""from __main__ import test_data, {name}"""
   __a					  =     500000
   __a					  =     timeit(stmt=SCREAMING_SNAKE_CASE__,       setup=SCREAMING_SNAKE_CASE__,       number=SCREAMING_SNAKE_CASE__     )
   print(f"""{name:<35} finished {number:,} runs in {result:.5f} seconds"""     )


if __name__ == "__main__":
 for key, value in test_data.items():
  assert is_palindrome(key) is is_palindrome_recursive(key)
  assert is_palindrome(key) is is_palindrome_slice(key)
  print(f"""{key:21} {value}""")
 print("""a man a plan a canal panama""")

 # finished 500,000 runs in 0.46793 seconds
 benchmark_function("""is_palindrome_slice""")
 # finished 500,000 runs in 0.85234 seconds
 benchmark_function("""is_palindrome""")
 # finished 500,000 runs in 1.32028 seconds
 benchmark_function("""is_palindrome_recursive""")
 # finished 500,000 runs in 2.08679 seconds
 benchmark_function("""is_palindrome_traversal""")