
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()

class  UpperCamelCase__ ( unittest.TestCase			):






      @property
      def 	__lowercase(     self					:   Union[str, Any]   )  -> Optional[int]:
           UpperCamelCase__							:  List[Any]								=     1
           UpperCamelCase__							:  Union[str, Any]								=     3
           UpperCamelCase__							:  List[Any]								=     (32, 32)

           UpperCamelCase__							:  Optional[int]								=     floats_tensor((batch_size, num_channels) + sizes,		rng=random.Random(0   )   ).to(__lowerCamelCase   )
           return image






      @property
      def 	__lowercase(     self					:   Optional[Any]   )  -> str:
           torch.manual_seed(0   )
           UpperCamelCase__							:  str								=     UNetaDModel(
               block_out_channels=(32, 64),		layers_per_block=2,		sample_size=32,		in_channels=6,		out_channels=3,		down_block_types=('''DownBlock2D''', '''AttnDownBlock2D'''),		up_block_types=('''AttnUpBlock2D''', '''UpBlock2D'''),		)
           return model






      @property
      def 	__lowercase(     self					:   Union[str, Any]   )  -> str:
           torch.manual_seed(0   )
           UpperCamelCase__							:  Optional[int]								=     VQModel(
               block_out_channels=[32, 64],		in_channels=3,		out_channels=3,		down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],		up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],		latent_channels=3,		)
           return model






      def 	__lowercase(     self					:   Optional[Any]   )  -> Dict:
           UpperCamelCase__							:  Optional[Any]								=     '''cpu'''
           UpperCamelCase__							:  Any								=     self.dummy_uncond_unet
           UpperCamelCase__							:  Dict								=     DDIMScheduler()
           UpperCamelCase__							:  Optional[Any]								=     self.dummy_vq_model

           UpperCamelCase__							:  List[str]								=     LDMSuperResolutionPipeline(unet=__lowerCamelCase,		vqvae=__lowerCamelCase,		scheduler=__lowerCamelCase   )
           ldm.to(__lowerCamelCase   )
           ldm.set_progress_bar_config(disable=__lowerCamelCase   )

           UpperCamelCase__							:  Any								=     self.dummy_image.to(__lowerCamelCase   )

           UpperCamelCase__							:  Any								=     torch.Generator(device=__lowerCamelCase   ).manual_seed(0   )
           UpperCamelCase__							:  List[str]								=     ldm(image=__lowerCamelCase,		generator=__lowerCamelCase,		num_inference_steps=2,		output_type='''numpy'''   ).images

           UpperCamelCase__							:  List[Any]								=     image[0, -3:, -3:, -1]

           assert image.shape == (1, 64, 64, 3)
           UpperCamelCase__							:  Optional[int]								=     np.array([0.8678, 0.8245, 0.6381, 0.6830, 0.4385, 0.5599, 0.4641, 0.6201, 0.5150]   )

           assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2






      @unittest.skipIf(torch_device != '''cuda''',		'''This test requires a GPU'''   )
      def 	__lowercase(     self					:   Dict   )  -> Tuple:
           UpperCamelCase__							:  Dict								=     self.dummy_uncond_unet
           UpperCamelCase__							:  Optional[Any]								=     DDIMScheduler()
           UpperCamelCase__							:  Dict								=     self.dummy_vq_model

           # put models in fp16
           UpperCamelCase__							:  str								=     unet.half()
           UpperCamelCase__							:  Dict								=     vqvae.half()

           UpperCamelCase__							:  List[str]								=     LDMSuperResolutionPipeline(unet=__lowerCamelCase,		vqvae=__lowerCamelCase,		scheduler=__lowerCamelCase   )
           ldm.to(__lowerCamelCase   )
           ldm.set_progress_bar_config(disable=__lowerCamelCase   )

           UpperCamelCase__							:  List[str]								=     self.dummy_image.to(__lowerCamelCase   )

           UpperCamelCase__							:  str								=     ldm(__lowerCamelCase,		num_inference_steps=2,		output_type='''numpy'''   ).images

           assert image.shape == (1, 64, 64, 3)

@slow
@require_torch
class  UpperCamelCase__ ( unittest.TestCase			):






      def 	__lowercase(     self					:   List[str]   )  -> Union[str, Any]:
           UpperCamelCase__							:  str								=     load_image(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/vq_diffusion/teddy_bear_pool.png'''   )
           UpperCamelCase__							:  Dict								=     init_image.resize((64, 64),		resample=PIL_INTERPOLATION['''lanczos''']   )

           UpperCamelCase__							:  Optional[int]								=     LDMSuperResolutionPipeline.from_pretrained('''duongna/ldm-super-resolution''',		device_map='''auto'''   )
           ldm.set_progress_bar_config(disable=__lowerCamelCase   )

           UpperCamelCase__							:  Union[str, Any]								=     torch.manual_seed(0   )
           UpperCamelCase__							:  Optional[Any]								=     ldm(image=__lowerCamelCase,		generator=__lowerCamelCase,		num_inference_steps=20,		output_type='''numpy'''   ).images

           UpperCamelCase__							:  Optional[int]								=     image[0, -3:, -3:, -1]

           assert image.shape == (1, 2_56, 2_56, 3)
           UpperCamelCase__							:  Any								=     np.array([0.7644, 0.7679, 0.7642, 0.7633, 0.7666, 0.7560, 0.7425, 0.7257, 0.6907]   )

           assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_SCREAMING_SNAKE_CASE :					Optional[Any]			=	{
    """configuration_layoutlm""": ["""LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LayoutLMConfig""", """LayoutLMOnnxConfig"""],
    """tokenization_layoutlm""": ["""LayoutLMTokenizer"""],
}

try:
   if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _SCREAMING_SNAKE_CASE :					Dict			=	["""LayoutLMTokenizerFast"""]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _SCREAMING_SNAKE_CASE :					List[str]			=	[
       """LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """LayoutLMForMaskedLM""",
       """LayoutLMForSequenceClassification""",
       """LayoutLMForTokenClassification""",
       """LayoutLMForQuestionAnswering""",
       """LayoutLMModel""",
       """LayoutLMPreTrainedModel""",
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _SCREAMING_SNAKE_CASE :					str			=	[
       """TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TFLayoutLMForMaskedLM""",
       """TFLayoutLMForSequenceClassification""",
       """TFLayoutLMForTokenClassification""",
       """TFLayoutLMForQuestionAnswering""",
       """TFLayoutLMMainLayer""",
       """TFLayoutLMModel""",
       """TFLayoutLMPreTrainedModel""",
   ]


if TYPE_CHECKING:
   from .configuration_layoutlm import LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMConfig, LayoutLMOnnxConfig
   from .tokenization_layoutlm import LayoutLMTokenizer

   try:
      if not is_tokenizers_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_layoutlm_fast import LayoutLMTokenizerFast

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_layoutlm import (
          LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          LayoutLMForMaskedLM,
          LayoutLMForQuestionAnswering,
          LayoutLMForSequenceClassification,
          LayoutLMForTokenClassification,
          LayoutLMModel,
          LayoutLMPreTrainedModel,
      )
   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_layoutlm import (
          TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFLayoutLMForMaskedLM,
          TFLayoutLMForQuestionAnswering,
          TFLayoutLMForSequenceClassification,
          TFLayoutLMForTokenClassification,
          TFLayoutLMMainLayer,
          TFLayoutLMModel,
          TFLayoutLMPreTrainedModel,
      )

else:
   import sys

   _SCREAMING_SNAKE_CASE :					Any			=	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




