






import os
import sys
import unittest


lowerCamelCase			:					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
lowerCamelCase			:					Any         =	os.path.join(git_repo_path, '''src''', '''diffusers''')



class 							_UpperCamelCase			(unittest.TestCase			):


      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					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")

           __lowerCAmelCase								=					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")

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


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase								=					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  __UpperCAmelCase		(	self	)->	Any:
           __lowerCAmelCase								=					create_dummy_object("CONSTANT"					,						"'torch'"	)
           self.assertEqual(__UpperCamelCase					,						"\nCONSTANT = None\n"	)

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

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


      def  __UpperCAmelCase		(	self	)->	Tuple:
           __lowerCAmelCase								=					"# 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"
           __lowerCAmelCase								=					create_dummy_files({"torch": ["CONSTANT", "function", "FakeClass"]}	)
           self.assertEqual(dummy_files["torch"]					,						__UpperCamelCase	)














from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional

from packaging import version


if TYPE_CHECKING:
 from ... import PreTrainedTokenizer, TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import is_torch_available, logging


lowerCamelCase			:					List[str]         =	logging.get_logger(__name__)

lowerCamelCase			:					Any         =	{
    '''bigscience/bloom''': '''https://huggingface.co/bigscience/bloom/resolve/main/config.json''',
    '''bigscience/bloom-560m''': '''https://huggingface.co/bigscience/bloom-560m/blob/main/config.json''',
    '''bigscience/bloom-1b1''': '''https://huggingface.co/bigscience/bloom-1b1/blob/main/config.json''',
    '''bigscience/bloom-1b7''': '''https://huggingface.co/bigscience/bloom-1b7/blob/main/config.json''',
    '''bigscience/bloom-3b''': '''https://huggingface.co/bigscience/bloom-3b/blob/main/config.json''',
    '''bigscience/bloom-7b1''': '''https://huggingface.co/bigscience/bloom-7b1/blob/main/config.json''',
}



class 							_UpperCamelCase			(a_			):
      snake_case_  =							"""bloom"""
      snake_case_  =							["""past_key_values"""]
      snake_case_  =							{
          """num_hidden_layers""": """n_layer""",
          """num_attention_heads""": """n_head""",
      }


      def __init__(	self					,						__UpperCamelCase=2_5_0_8_8_0					,						__UpperCamelCase=6_4					,						__UpperCamelCase=2					,						__UpperCamelCase=8					,						__UpperCamelCase=1e-5					,						__UpperCamelCase=0.0_2					,						__UpperCamelCase=True					,						__UpperCamelCase=1					,						__UpperCamelCase=2					,						__UpperCamelCase=False					,						__UpperCamelCase=0.0					,						__UpperCamelCase=0.0					,						__UpperCamelCase=1					,						__UpperCamelCase=False					,						**__UpperCamelCase					,						)->	Dict:
           __lowerCAmelCase								=					vocab_size
           # Backward compatibility with n_embed kwarg
           __lowerCAmelCase								=					kwargs.pop("n_embed"					,						__UpperCamelCase	)
           __lowerCAmelCase								=					hidden_size if n_embed is None else n_embed
           __lowerCAmelCase								=					n_layer
           __lowerCAmelCase								=					n_head
           __lowerCAmelCase								=					layer_norm_epsilon
           __lowerCAmelCase								=					initializer_range
           __lowerCAmelCase								=					use_cache
           __lowerCAmelCase								=					pretraining_tp
           __lowerCAmelCase								=					apply_residual_connection_post_layernorm
           __lowerCAmelCase								=					hidden_dropout
           __lowerCAmelCase								=					attention_dropout

           __lowerCAmelCase								=					bos_token_id
           __lowerCAmelCase								=					eos_token_id
           __lowerCAmelCase								=					slow_but_exact

           super().__init__(bos_token_id=__UpperCamelCase					,						eos_token_id=__UpperCamelCase					,						**__UpperCamelCase	)



class 							_UpperCamelCase			(a_			):
      snake_case_  =							version.parse("""1.12"""			)


      def __init__(	self					,						__UpperCamelCase					,						__UpperCamelCase = "default"					,						__UpperCamelCase = None					,						__UpperCamelCase = False					,						)->	str:
           super().__init__(__UpperCamelCase					,						task=__UpperCamelCase					,						patching_specs=__UpperCamelCase					,						use_past=__UpperCamelCase	)
           if not getattr(self._config					,						"pad_token_id"					,						__UpperCamelCase	):
                # TODO: how to do that better?
                __lowerCAmelCase								=					0


      @property
      def  __UpperCAmelCase		(	self	)->	Mapping[str, Mapping[int, str]]:
           __lowerCAmelCase								=					OrderedDict({"input_ids": {0: "batch", 1: "sequence"}}	)
           if self.use_past:
                # BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
                self.fill_with_past_key_values_(__UpperCamelCase					,						direction="inputs"					,						inverted_values_shape=__UpperCamelCase	)
                __lowerCAmelCase								=					{0: "batch", 1: "past_sequence + sequence"}
           else:
                __lowerCAmelCase								=					{0: "batch", 1: "sequence"}

           return common_inputs


      @property
      def  __UpperCAmelCase		(	self	)->	int:
           return self._config.n_layer


      @property
      def  __UpperCAmelCase		(	self	)->	int:
           return self._config.n_head


      @property
      def  __UpperCAmelCase		(	self	)->	float:
           return 1e-3


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase = -1					,						__UpperCamelCase = -1					,						__UpperCamelCase = False					,						__UpperCamelCase = None					,						)->	Mapping[str, Any]:
           __lowerCAmelCase								=					super(__UpperCamelCase					,						self	).generate_dummy_inputs(
               __UpperCamelCase					,						batch_size=__UpperCamelCase					,						seq_length=__UpperCamelCase					,						is_pair=__UpperCamelCase					,						framework=__UpperCamelCase	)

           # We need to order the input in the way they appears in the forward()
           __lowerCAmelCase								=					OrderedDict({"input_ids": common_inputs["input_ids"]}	)

           # Need to add the past_keys
           if self.use_past:
                if not is_torch_available():
                     raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."	)
                else:
                     import torch

                     __lowerCAmelCase			, __lowerCAmelCase								=					common_inputs["input_ids"].shape
                     # Not using the same length for past_key_values
                     __lowerCAmelCase								=					seqlen + 2
                     __lowerCAmelCase								=					self._config.hidden_size // self.num_attention_heads
                     __lowerCAmelCase								=					(
                         batch * self.num_attention_heads,
                         head_dim,
                         past_key_values_length,
                     )
                     __lowerCAmelCase								=					(
                         batch * self.num_attention_heads,
                         past_key_values_length,
                         head_dim,
                     )
                     __lowerCAmelCase								=					[
                         (torch.zeros(__UpperCamelCase	), torch.zeros(__UpperCamelCase	)) for _ in range(self.num_layers	)
                     ]

           __lowerCAmelCase								=					common_inputs["attention_mask"]
           if self.use_past:
                __lowerCAmelCase								=					ordered_inputs["attention_mask"].dtype
                __lowerCAmelCase								=					torch.cat(
                    [ordered_inputs["attention_mask"], torch.ones(__UpperCamelCase					,						__UpperCamelCase					,						dtype=__UpperCamelCase	)]					,						dim=1	)

           return ordered_inputs


      @property
      def  __UpperCAmelCase		(	self	)->	int:
           return 1_3






