


'''simple docstring'''






from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def 		_A ()      ->     str:




     '''simple docstring'''



     import os as original_os
     from os import path as original_path
     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     assert _test_patching.os is original_os
     assert _test_patching.path is original_path
     assert _test_patching.join is original_join

     assert _test_patching.renamed_os is original_os
     assert _test_patching.renamed_path is original_path
     assert _test_patching.renamed_join is original_join

     _a						=							"__test_patch_submodule_mock__"
     with patch_submodule(_test_patching ,  'os.path.join' ,  __lowerCamelCase						):
          # Every way to access os.path.join must be patched, and the rest must stay untouched

          # check os.path.join
          assert isinstance(_test_patching.os ,  _PatchedModuleObj						)
          assert isinstance(_test_patching.os.path ,  _PatchedModuleObj						)
          assert _test_patching.os.path.join is mock

          # check path.join
          assert isinstance(_test_patching.path ,  _PatchedModuleObj						)
          assert _test_patching.path.join is mock

          # check join
          assert _test_patching.join is mock

          # check that the other attributes are untouched
          assert _test_patching.os.rename is original_rename
          assert _test_patching.path.dirname is original_dirname
          assert _test_patching.os.path.dirname is original_dirname

          # Even renamed modules or objects must be patched

          # check renamed_os.path.join
          assert isinstance(_test_patching.renamed_os ,  _PatchedModuleObj						)
          assert isinstance(_test_patching.renamed_os.path ,  _PatchedModuleObj						)
          assert _test_patching.renamed_os.path.join is mock

          # check renamed_path.join
          assert isinstance(_test_patching.renamed_path ,  _PatchedModuleObj						)
          assert _test_patching.renamed_path.join is mock

          # check renamed_join
          assert _test_patching.renamed_join is mock

          # check that the other attributes are untouched
          assert _test_patching.renamed_os.rename is original_rename
          assert _test_patching.renamed_path.dirname is original_dirname
          assert _test_patching.renamed_os.path.dirname is original_dirname

     # check that everthing is back to normal when the patch is over

     assert _test_patching.os is original_os
     assert _test_patching.path is original_path
     assert _test_patching.join is original_join

     assert _test_patching.renamed_os is original_os
     assert _test_patching.renamed_path is original_path
     assert _test_patching.renamed_join is original_join






def 		_A ()      ->     str:




     '''simple docstring'''



     assert _test_patching.open is open

     _a						=							"__test_patch_submodule_builtin_mock__"
     # _test_patching has "open" in its globals
     assert _test_patching.open is open
     with patch_submodule(_test_patching ,  'open' ,  __lowerCamelCase						):
          assert _test_patching.open is mock

     # check that everthing is back to normal when the patch is over

     assert _test_patching.open is open






def 		_A ()      ->     Union[str, Any]:




     '''simple docstring'''



     _a						=							"__test_patch_submodule_missing_mock__"
     with patch_submodule(_test_patching ,  'pandas.read_csv' ,  __lowerCamelCase						):
          pass






def 		_A ()      ->     Tuple:




     '''simple docstring'''



     _a						=							"__test_patch_submodule_missing_builtin_mock__"
     # _test_patching doesn't have "len" in its globals
     assert getattr(_test_patching ,  'len' ,  __lowerCamelCase						) is None
     with patch_submodule(_test_patching ,  'len' ,  __lowerCamelCase						):
          assert _test_patching.len is mock
     assert _test_patching.len is len






def 		_A ()      ->     Dict:




     '''simple docstring'''



     _a						=							"__test_patch_submodule_start_and_stop_mock__"
     _a						=							patch_submodule(_test_patching ,  'open' ,  __lowerCamelCase						)
     assert _test_patching.open is open
     patch.start()
     assert _test_patching.open is mock
     patch.stop()
     assert _test_patching.open is open






def 		_A ()      ->     Dict:




     '''simple docstring'''



     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     _a						=							"__test_patch_submodule_successive_join__"
     _a						=							"__test_patch_submodule_successive_dirname__"
     _a						=							"__test_patch_submodule_successive_rename__"
     assert _test_patching.os.path.join is original_join
     assert _test_patching.os.path.dirname is original_dirname
     assert _test_patching.os.rename is original_rename

     with patch_submodule(_test_patching ,  'os.path.join' ,  __lowerCamelCase						):
          with patch_submodule(_test_patching ,  'os.rename' ,  __lowerCamelCase						):
               with patch_submodule(_test_patching ,  'os.path.dirname' ,  __lowerCamelCase						):
                    assert _test_patching.os.path.join is mock_join
                    assert _test_patching.os.path.dirname is mock_dirname
                    assert _test_patching.os.rename is mock_rename

    # try another order
     with patch_submodule(_test_patching ,  'os.rename' ,  __lowerCamelCase						):
          with patch_submodule(_test_patching ,  'os.path.join' ,  __lowerCamelCase						):
               with patch_submodule(_test_patching ,  'os.path.dirname' ,  __lowerCamelCase						):
                    assert _test_patching.os.path.join is mock_join
                    assert _test_patching.os.path.dirname is mock_dirname
                    assert _test_patching.os.rename is mock_rename

     assert _test_patching.os.path.join is original_join
     assert _test_patching.os.path.dirname is original_dirname
     assert _test_patching.os.rename is original_rename






def 		_A ()      ->     List[str]:




     '''simple docstring'''



     _a						=							"__test_patch_submodule_doesnt_exist_mock__"
     with patch_submodule(_test_patching ,  '__module_that_doesn_exist__.__attribute_that_doesn_exist__' ,  __lowerCamelCase						):
          pass
     with patch_submodule(_test_patching ,  'os.__attribute_that_doesn_exist__' ,  __lowerCamelCase						):
          pass








'''simple docstring'''


lowerCAmelCase					:     Optional[int]												=256
# Modulus to hash a string
lowerCAmelCase					:     Tuple												=1_000_003
def 							UpperCAmelCase_  (						__lowerCamelCase					:					str	,__lowerCamelCase					:					str ):
   lowercase_			:Dict    			= len(__lowerCamelCase )
   lowercase_			:int    			= len(__lowerCamelCase )
   if p_len > t_len:
      return False

   lowercase_			:Any    			= 0
   lowercase_			:Dict    			= 0
   lowercase_			:int    			= 1

   # Calculating the hash of pattern and substring of text
   for i in range(__lowerCamelCase ):
      lowercase_			:Union[str, Any]    			= (ord(pattern[i] ) + p_hash * alphabet_size) % modulus
      lowercase_			:Tuple    			= (ord(text[i] ) + text_hash * alphabet_size) % modulus
      if i == p_len - 1:
         continue
      lowercase_			:Tuple    			= (modulus_power * alphabet_size) % modulus

   for i in range(0	,t_len - p_len + 1 ):
      if text_hash == p_hash and text[i : i + p_len] == pattern:
         return True
      if i == t_len - p_len:
         continue
      # Calculate the https://en.wikipedia.org/wiki/Rolling_hash
      lowercase_			:Tuple    			= (
          (text_hash - ord(text[i] ) * modulus_power) * alphabet_size
          + ord(text[i + p_len] )
      ) % modulus
   return False
def 							UpperCAmelCase_  (						):
   lowercase_			:List[Any]    			= "abc1abc12"
   lowercase_			:List[str]    			= "alskfjaldsabc1abc1abc12k23adsfabcabc"
   lowercase_			:int    			= "alskfjaldsk23adsfabcabc"
   assert rabin_karp(__lowerCamelCase	,__lowerCamelCase ) and not rabin_karp(__lowerCamelCase	,__lowerCamelCase )

   # Test 2)
   lowercase_			:Union[str, Any]    			= "ABABX"
   lowercase_			:Optional[Any]    			= "ABABZABABYABABX"
   assert rabin_karp(__lowerCamelCase	,__lowerCamelCase )

   # Test 3)
   lowercase_			:Dict    			= "AAAB"
   lowercase_			:int    			= "ABAAAAAB"
   assert rabin_karp(__lowerCamelCase	,__lowerCamelCase )

   # Test 4)
   lowercase_			:Tuple    			= "abcdabcy"
   lowercase_			:Union[str, Any]    			= "abcxabcdabxabcdabcdabcy"
   assert rabin_karp(__lowerCamelCase	,__lowerCamelCase )

   # Test 5)
   lowercase_			:Tuple    			= "Lü"
   lowercase_			:List[Any]    			= "Lüsai"
   assert rabin_karp(__lowerCamelCase	,__lowerCamelCase )
   lowercase_			:str    			= "Lue"
   assert not rabin_karp(__lowerCamelCase	,__lowerCamelCase )
   print("Success." )


if __name__ == "__main__":
 test_rabin_karp()


