


import os
import sys
import unittest


_UpperCAmelCase			:  int     =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
_UpperCAmelCase			:  Union[str, Any]     =os.path.join(git_repo_path, """src""", """diffusers""")







class 				snake_case__(							unittest.TestCase							):







						'''simple docstring'''




						def 						lowercase_ (				self							)					->    Optional[Any]:
										lowerCAmelCase_ :      Any    				=				find_backend('''    if not is_torch_available():'''							)
										self.assertEqual(__lowercase   ,						'''torch'''							)

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

										lowerCAmelCase_ :      List[str]    				=				find_backend('''    if not (is_torch_available() and is_transformers_available()):'''							)
										self.assertEqual(__lowercase   ,						'''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")

										lowerCAmelCase_ :      Dict    				=				find_backend(
										    '''    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):'''							)
										self.assertEqual(__lowercase   ,						'''torch_and_transformers_and_onnx'''							)




						def 						lowercase_ (				self							)					->    Dict:
										lowerCAmelCase_ :      Union[str, Any]    				=				read_init()
										# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
										self.assertIn('''torch'''   ,						__lowercase							)
										self.assertIn('''torch_and_transformers'''   ,						__lowercase							)
										self.assertIn('''flax_and_transformers'''   ,						__lowercase							)
										self.assertIn('''torch_and_transformers_and_onnx'''   ,						__lowercase							)

										# 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 						lowercase_ (				self							)					->    Union[str, Any]:
										lowerCAmelCase_ :      Dict    				=				create_dummy_object('''CONSTANT'''   ,						'''\'torch\''''							)
										self.assertEqual(__lowercase   ,						'''\nCONSTANT = None\n'''							)

										lowerCAmelCase_ :      Optional[int]    				=				create_dummy_object('''function'''   ,						'''\'torch\''''							)
										self.assertEqual(
										    __lowercase   ,						'''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''							)

										lowerCAmelCase_ :      List[Any]    				=				'''
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\')
'''
										lowerCAmelCase_ :      List[Any]    				=				create_dummy_object('''FakeClass'''   ,						'''\'torch\''''							)
										self.assertEqual(__lowercase   ,						__lowercase							)




						def 						lowercase_ (				self							)					->    Tuple:
										lowerCAmelCase_ :      Any    				=				'''# 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"])
'''
										lowerCAmelCase_ :      Dict    				=				create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}							)
										self.assertEqual(dummy_files['''torch''']   ,						__lowercase							)



_UpperCAmelCase			:  Dict     =[
    (1000, """M"""),
    (900, """CM"""),
    (500, """D"""),
    (400, """CD"""),
    (100, """C"""),
    (90, """XC"""),
    (50, """L"""),
    (40, """XL"""),
    (10, """X"""),
    (9, """IX"""),
    (5, """V"""),
    (4, """IV"""),
    (1, """I"""),
]



def 			lowerCAmelCase (		lowerCAmelCase_ )-> int:
				lowerCAmelCase_ :      Any    				=				{'''I''': 1, '''V''': 5, '''X''': 10, '''L''': 50, '''C''': 100, '''D''': 500, '''M''': 1_000}
				lowerCAmelCase_ :      Optional[int]    				=				0
				lowerCAmelCase_ :      List[str]    				=				0
				while place < len(lowerCAmelCase_ ):
								if (place + 1 < len(lowerCAmelCase_ )) and (vals[roman[place]] < vals[roman[place + 1]]):
												total += vals[roman[place + 1]] - vals[roman[place]]
												place += 2
								else:
												total += vals[roman[place]]
												place += 1
				return total



def 			lowerCAmelCase (		lowerCAmelCase_ )-> str:
				lowerCAmelCase_ :      List[Any]    				=				[]
				for arabic, roman in ROMAN:
								((lowerCAmelCase_)				,  (lowerCAmelCase_)) :      Optional[int]    				=				divmod(lowerCAmelCase_ ,   lowerCAmelCase_ )
								result.append(roman * factor )
								if number == 0:
												break
				return "".join(lowerCAmelCase_ )


if __name__ == "__main__":
						import doctest

						doctest.testmod()