





"""simple docstring"""




import os
import sys
import unittest


SCREAMING_SNAKE_CASE_						       =	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
SCREAMING_SNAKE_CASE_						       =	os.path.join(git_repo_path, """src""", """diffusers""")

class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     def     SCREAMING_SNAKE_CASE__  (							self						:   List[str]	)					->		Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						find_backend("""    if not is_torch_available():"""	)
           self.assertEqual(UpperCamelCase__						,"""torch"""	)

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

           SCREAMING_SNAKE_CASE		=						find_backend("""    if not (is_torch_available() and is_transformers_available()):"""	)
           self.assertEqual(UpperCamelCase__						,"""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")

           SCREAMING_SNAKE_CASE		=						find_backend(
               """    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):"""	)
           self.assertEqual(UpperCamelCase__						,"""torch_and_transformers_and_onnx"""	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   int	)					->		Any:




           '''simple docstring'''


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

           # 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     SCREAMING_SNAKE_CASE__  (							self						:   Any	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						create_dummy_object("""CONSTANT"""						,"""\'torch\'"""	)
           self.assertEqual(UpperCamelCase__						,"""\nCONSTANT = None\n"""	)

           SCREAMING_SNAKE_CASE		=						create_dummy_object("""function"""						,"""\'torch\'"""	)
           self.assertEqual(
               UpperCamelCase__						,"""\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n"""	)

           SCREAMING_SNAKE_CASE		=						'''
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\')
'''
           SCREAMING_SNAKE_CASE		=						create_dummy_object("""FakeClass"""						,"""\'torch\'"""	)
           self.assertEqual(UpperCamelCase__						,UpperCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						'''# 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"])
'''
           SCREAMING_SNAKE_CASE		=						create_dummy_files({"""torch""": ["""CONSTANT""", """function""", """FakeClass"""]}	)
           self.assertEqual(dummy_files["""torch"""]						,UpperCamelCase__	)









def        __lowercase       (				_SCREAMING_SNAKE_CASE = 50     )			->       int:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						[1] * (length + 1)

      for row_length in range(3			,						length + 1     ):
            for block_length in range(3			,						row_length + 1     ):
                  for block_start in range(row_length - block_length     ):
                        ways_number[row_length] += ways_number[
                            row_length - block_start - block_length - 1
                        ]

                  ways_number[row_length] += 1

      return ways_number[length]


if __name__ == "__main__":
      print(F'''{solution() = }''')


