



"""simple docstring"""






import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
   from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
   from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
   from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


lowerCAmelCase__        =				DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

lowerCAmelCase__        =				"main"
# Default branch name
lowerCAmelCase__        =				"f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"
# One particular commit (not the top of `main`)
lowerCAmelCase__        =				"aaaaaaa"
# This commit does not exist, so we should 404.

lowerCAmelCase__        =				"d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"
# Sha-1 of config.json on the top of `main`, for checking purposes
lowerCAmelCase__        =				"4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"






@contextlib.contextmanager
def        snake_case_  (      ):


       '''simple docstring'''





       print('''Welcome!'''						)
       yield
       print('''Bye!'''						)






@contextlib.contextmanager
def        snake_case_  (      ):


       '''simple docstring'''





       print('''Bonjour!'''						)
       yield
       print('''Au revoir!'''						)






class        __snake_case       (	unittest.TestCase):




  def 						SCREAMING_SNAKE_CASE				( self     :						Union[str, Any]		):






         """simple docstring"""






         assert transformers.__spec__ is not None
         assert importlib.util.find_spec('''transformers'''		) is not None






class        __snake_case       (	unittest.TestCase):




  @unittest.mock.patch('''sys.stdout'''						,					new_callable=io.StringIO		)
  def 						SCREAMING_SNAKE_CASE				( self     :						Tuple						,					__lowerCAmelCase     :						Union[str, Any]		):






         """simple docstring"""






         with ContextManagers([]		):
                print('''Transformers are awesome!'''		)
         # The print statement adds a new line at the end of the output
         self.assertEqual(mock_stdout.getvalue()						,					'''Transformers are awesome!\n'''		)




  @unittest.mock.patch('''sys.stdout'''						,					new_callable=io.StringIO		)
  def 						SCREAMING_SNAKE_CASE				( self     :						Dict						,					__lowerCAmelCase     :						Union[str, Any]		):






         """simple docstring"""






         with ContextManagers([context_en()]		):
                print('''Transformers are awesome!'''		)
         # The output should be wrapped with an English welcome and goodbye
         self.assertEqual(mock_stdout.getvalue()						,					'''Welcome!\nTransformers are awesome!\nBye!\n'''		)




  @unittest.mock.patch('''sys.stdout'''						,					new_callable=io.StringIO		)
  def 						SCREAMING_SNAKE_CASE				( self     :						Tuple						,					__lowerCAmelCase     :						str		):






         """simple docstring"""






         with ContextManagers([context_fr(), context_en()]		):
                print('''Transformers are awesome!'''		)
         # The output should be wrapped with an English and French welcome and goodbye
         self.assertEqual(mock_stdout.getvalue()						,					'''Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n'''		)




  @require_torch
  def 						SCREAMING_SNAKE_CASE				( self     :						List[str]		):






         """simple docstring"""






         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''labels''']		)
         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''labels''', '''next_sentence_label''']		)
         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''start_positions''', '''end_positions''']		)






         class        __snake_case       (	SCREAMING_SNAKE_CASE__):
           pass


         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''labels''']		)




  @require_tf
  def 						SCREAMING_SNAKE_CASE				( self     :						List[str]		):






         """simple docstring"""






         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''labels''']		)
         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''labels''', '''next_sentence_label''']		)
         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''start_positions''', '''end_positions''']		)






         class        __snake_case       (	SCREAMING_SNAKE_CASE__):
           pass


         self.assertEqual(find_labels(__lowerCAmelCase		)						,					['''labels''']		)




  @require_flax
  def 						SCREAMING_SNAKE_CASE				( self     :						int		):






         """simple docstring"""






         self.assertEqual(find_labels(__lowerCAmelCase		)						,					[]		)
         self.assertEqual(find_labels(__lowerCAmelCase		)						,					[]		)
         self.assertEqual(find_labels(__lowerCAmelCase		)						,					[]		)






         class        __snake_case       (	SCREAMING_SNAKE_CASE__):
           pass


         self.assertEqual(find_labels(__lowerCAmelCase		)						,					[]		)



from __future__ import annotations


class      lowerCamelCase    :
  """simple docstring"""







  def __init__(							self       :				Union[str, Any]     ,   __magic_name__       :				str     ,   __magic_name__       :				str      )     ->		Dict:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     text, pattern
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     len(__magic_name__      ), len(__magic_name__      )







  def       __A   (							self       :				List[str]     ,   __magic_name__       :				str      )     ->		int:

        for i in range(self.patLen - 1     ,   -1     ,   -1      ):
              if char == self.pattern[i]:
                    return i
        return -1







  def       __A   (							self       :				Dict     ,   __magic_name__       :				int      )     ->		int:

        for i in range(self.patLen - 1     ,   -1     ,   -1      ):
              if self.pattern[i] != self.text[current_pos + i]:
                    return current_pos + i
        return -1







  def       __A   (							self       :				Tuple      )     ->		list[int]:
        # searches pattern in text and returns index positions
        SCREAMING_SNAKE_CASE_      =     []
        for i in range(self.textLen - self.patLen + 1      ):
              SCREAMING_SNAKE_CASE_      =     self.mismatch_in_text(__magic_name__      )
              if mismatch_index == -1:
                    positions.append(__magic_name__      )
              else:
                    SCREAMING_SNAKE_CASE_      =     self.match_in_pattern(self.text[mismatch_index]      )
                    SCREAMING_SNAKE_CASE_      =     (
                        mismatch_index - match_index
                    )  # shifting index lgtm [py/multiple-definition]
        return positions



A   :     Dict       =				"ABAABA"
A   :     Union[str, Any]       =				"AB"
A   :     str       =				BoyerMooreSearch(text, pattern)
A   :     Tuple       =				bms.bad_character_heuristic()

if len(positions) == 0:
      print("No match found")
else:
      print("Pattern found in following positions: ")
      print(positions)


