


"""simple docstring"""







from string import ascii_uppercase

__lowercase    					=      {str(ord(c) - 55): c for c in ascii_uppercase}


def      lowercase			(				A_  ,   A_       )->      str:
  '''simple docstring'''







  if isinstance(A_  ,   A_       ):
    raise TypeError("int() can't convert non-string with explicit base"       )
  if num < 0:
    raise ValueError("parameter must be positive int"       )
  if isinstance(A_  ,   A_       ):
    raise TypeError("'str' object cannot be interpreted as an integer"       )
  if isinstance(A_  ,   A_       ):
    raise TypeError("'float' object cannot be interpreted as an integer"       )
  if base in (0, 1):
    raise ValueError("base must be >= 2"       )
  if base > 36:
    raise ValueError("base must be <= 36"       )
  a						:		Tuple      							=			""
  a						:		Optional[Any]      							=			0
  a						:		Optional[Any]      							=			0
  while div != 1:
    a							,		a						:		Union[str, Any]      							=			divmod(A_  ,   A_       )
    if base >= 11 and 9 < mod < 36:
      a						:		Any      							=			ALPHABET_VALUES[str(A_       )]
    else:
      a						:		Optional[Any]      							=			str(A_       )
    new_value += actual_value
    a						:		Union[str, Any]      							=			num // base
    a						:		Union[str, Any]      							=			div
    if div == 0:
      return str(new_value[::-1]       )
    elif div == 1:
      new_value += str(A_       )
      return str(new_value[::-1]       )

  return new_value[::-1]


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 for base in range(2, 37):
  for num in range(1000):
   assert int(decimal_to_any(num, base), base) == num, (
       num,
       base,
       decimal_to_any(num, base),
       int(decimal_to_any(num, base), base),
   )










"""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 	__snake_case							(					self				:    Any):
      a						:		List[Any]      							=			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")

      a						:		Dict      							=			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")

      a						:		int      							=			find_backend(
          "    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):")
      self.assertEqual(__UpperCAmelCase				, "torch_and_transformers_and_onnx")






    def 	__snake_case							(					self				:    Union[str, Any]):
      a						:		Dict      							=			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 	__snake_case							(					self				:    Tuple):
      a						:		Optional[int]      							=			create_dummy_object("CONSTANT"				, "'torch'")
      self.assertEqual(__UpperCAmelCase				, "\nCONSTANT = None\n")

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

      a						:		Optional[Any]      							=			"\nclass FakeClass(metaclass=DummyObject):\n    _backends = 'torch'\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, 'torch')\n\n    @classmethod\n    def from_config(cls, *args, **kwargs):\n        requires_backends(cls, 'torch')\n\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        requires_backends(cls, 'torch')\n"
      a						:		int      							=			create_dummy_object("FakeClass"				, "'torch'")
      self.assertEqual(__UpperCAmelCase				, __UpperCAmelCase)






    def 	__snake_case							(					self				:    List[str]):
      a						:		List[str]      							=			"# This file is autogenerated by the command `make fix-copies`, do not edit.\nfrom ..utils import DummyObject, requires_backends\n\n\nCONSTANT = None\n\n\ndef function(*args, **kwargs):\n    requires_backends(function, [\"torch\"])\n\n\nclass FakeClass(metaclass=DummyObject):\n    _backends = [\"torch\"]\n\n    def __init__(self, *args, **kwargs):\n        requires_backends(self, [\"torch\"])\n\n    @classmethod\n    def from_config(cls, *args, **kwargs):\n        requires_backends(cls, [\"torch\"])\n\n    @classmethod\n    def from_pretrained(cls, *args, **kwargs):\n        requires_backends(cls, [\"torch\"])\n"
      a						:		Tuple      							=			create_dummy_files({"torch": ["CONSTANT", "function", "FakeClass"]})
      self.assertEqual(dummy_files["torch"]				, __UpperCAmelCase)






