



'''simple docstring'''





import os
import sys
import unittest


lowercase_	 =						os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, "utils"))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
lowercase_	 =						os.path.join(git_repo_path, "src", "diffusers")






class __A    (						unittest.TestCase		):



 '''simple docstring'''







 def       a__						(self )					->  str:


      """simple docstring"""



      _a											=						find_backend('''    if not is_torch_available():''' )
      self.assertEqual(A				,     '''torch''' )

      # backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
      # self.assertEqual(backend_with_underscore, "tensorflow_text")

      _a											=						find_backend('''    if not (is_torch_available() and is_transformers_available()):''' )
      self.assertEqual(A				,     '''torch_and_transformers''' )

      # double_backend_with_underscore = find_backend(
      #    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
      # )
      # self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")

      _a											=						find_backend(
          '''    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):''' )
      self.assertEqual(A				,     '''torch_and_transformers_and_onnx''' )



 def       a__						(self )					->  List[str]:


      """simple docstring"""



      _a											=						read_init()
      # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
      self.assertIn('''torch'''				,     A )
      self.assertIn('''torch_and_transformers'''				,     A )
      self.assertIn('''flax_and_transformers'''				,     A )
      self.assertIn('''torch_and_transformers_and_onnx'''				,     A )

      # Likewise, we can't assert on the exact content of a key
      self.assertIn('''UNet2DModel'''				,     objects['''torch'''] )
      self.assertIn('''FlaxUNet2DConditionModel'''				,     objects['''flax'''] )
      self.assertIn('''StableDiffusionPipeline'''				,     objects['''torch_and_transformers'''] )
      self.assertIn('''FlaxStableDiffusionPipeline'''				,     objects['''flax_and_transformers'''] )
      self.assertIn('''LMSDiscreteScheduler'''				,     objects['''torch_and_scipy'''] )
      self.assertIn('''OnnxStableDiffusionPipeline'''				,     objects['''torch_and_transformers_and_onnx'''] )



 def       a__						(self )					->  Any:


      """simple docstring"""



      _a											=						create_dummy_object('''CONSTANT'''				,     '''\'torch\'''' )
      self.assertEqual(A				,     '''\nCONSTANT = None\n''' )

      _a											=						create_dummy_object('''function'''				,     '''\'torch\'''' )
      self.assertEqual(
          A				,     '''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n''' )

      _a											=						'''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, \'torch\')
'''
      _a											=						create_dummy_object('''FakeClass'''				,     '''\'torch\'''' )
      self.assertEqual(A				,     A )



 def       a__						(self )					->  Tuple:


      """simple docstring"""



      _a											=						'''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, ["torch"])

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, ["torch"])
'''
      _a											=						create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']} )
      self.assertEqual(dummy_files['''torch''']				,     A )








'''simple docstring'''





lowercase_	 =						256
# Modulus to hash a string
lowercase_	 =						1_000_003




def lowerCAmelCase						(__A						,			__A):



     """simple docstring"""



     _a											=						len(__A)
     _a											=						len(__A)
     if p_len > t_len:
          return False

     _a											=						0
     _a											=						0
     _a											=						1

     # Calculating the hash of pattern and substring of text
     for i in range(__A):
          _a											=						(ord(pattern[i]) + p_hash * alphabet_size) % modulus
          _a											=						(ord(text[i]) + text_hash * alphabet_size) % modulus
          if i == p_len - 1:
               continue
          _a											=						(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
          _a											=						(
              (text_hash - ord(text[i]) * modulus_power) * alphabet_size
              + ord(text[i + p_len])
          ) % modulus
     return False




def lowerCAmelCase						():



     """simple docstring"""



     _a											=						'''abc1abc12'''
     _a											=						'''alskfjaldsabc1abc1abc12k23adsfabcabc'''
     _a											=						'''alskfjaldsk23adsfabcabc'''
     assert rabin_karp(__A						,			__A) and not rabin_karp(__A						,			__A)

     # Test 2)
     _a											=						'''ABABX'''
     _a											=						'''ABABZABABYABABX'''
     assert rabin_karp(__A						,			__A)

     # Test 3)
     _a											=						'''AAAB'''
     _a											=						'''ABAAAAAB'''
     assert rabin_karp(__A						,			__A)

     # Test 4)
     _a											=						'''abcdabcy'''
     _a											=						'''abcxabcdabxabcdabcdabcy'''
     assert rabin_karp(__A						,			__A)

     # Test 5)
     _a											=						'''Lü'''
     _a											=						'''Lüsai'''
     assert rabin_karp(__A						,			__A)
     _a											=						'''Lue'''
     assert not rabin_karp(__A						,			__A)
     print('''Success.''')


if __name__ == "__main__":
  test_rabin_karp()



