



import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar





class 		UpperCAmelCase						(						unittest.TestCase				):





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  logging.get_logger()

         # the current default level is logging.WARNING
         _lowerCAmelCase 			=  logging.get_verbosity()

         logging.set_verbosity_error()
         self.assertEqual(logger.getEffectiveLevel()       ,     logging.get_verbosity()			)

         logging.set_verbosity_warning()
         self.assertEqual(logger.getEffectiveLevel()       ,     logging.get_verbosity()			)

         logging.set_verbosity_info()
         self.assertEqual(logger.getEffectiveLevel()       ,     logging.get_verbosity()			)

         logging.set_verbosity_debug()
         self.assertEqual(logger.getEffectiveLevel()       ,     logging.get_verbosity()			)

         # restore to the original level
         logging.set_verbosity(_lowerCAmelCase			)





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  logging.get_verbosity()

         _lowerCAmelCase 			=  logging.get_logger('''transformers.models.bart.tokenization_bart'''			)
         _lowerCAmelCase 			=  '''Testing 1, 2, 3'''

         # should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
         if level_origin <= logging.WARNING:
               with CaptureLogger(_lowerCAmelCase			) as cl:
                     logger.warning(_lowerCAmelCase			)
               self.assertEqual(cl.out       ,     msg + '''\n'''			)

         # this is setting the level for all of `transformers.*` loggers
         logging.set_verbosity_error()

         # should not be able to log warnings
         with CaptureLogger(_lowerCAmelCase			) as cl:
               logger.warning(_lowerCAmelCase			)
         self.assertEqual(cl.out       ,     ''''''			)

         # should be able to log warnings again
         logging.set_verbosity_warning()
         with CaptureLogger(_lowerCAmelCase			) as cl:
               logger.warning(_lowerCAmelCase			)
         self.assertEqual(cl.out       ,     msg + '''\n'''			)

         # restore to the original level
         logging.set_verbosity(_lowerCAmelCase			)





   @mockenv(TRANSFORMERS_VERBOSITY='''error'''			)
   def 	__lowerCAmelCase							(	self			):
         # reset for the env var to take effect, next time some logger call is made
         transformers.utils.logging._reset_library_root_logger()
         # this action activates the env var
         _lowerCAmelCase 			=  logging.get_logger('''transformers.models.bart.tokenization_bart'''			)

         _lowerCAmelCase 			=  os.getenv('''TRANSFORMERS_VERBOSITY'''       ,     _lowerCAmelCase			)
         _lowerCAmelCase 			=  logging.log_levels[env_level_str]

         _lowerCAmelCase 			=  logging.get_verbosity()
         self.assertEqual(
             _lowerCAmelCase       ,     _lowerCAmelCase       ,     F'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''       ,     )

         # restore to the original level
         _lowerCAmelCase 			=  ''''''
         transformers.utils.logging._reset_library_root_logger()





   @mockenv(TRANSFORMERS_VERBOSITY='''super-error'''			)
   def 	__lowerCAmelCase							(	self			):
         # reset for the env var to take effect, next time some logger call is made
         transformers.utils.logging._reset_library_root_logger()
         _lowerCAmelCase 			=  logging.logging.getLogger()
         with CaptureLogger(_lowerCAmelCase			) as cl:
               # this action activates the env var
               logging.get_logger('''transformers.models.bart.tokenization_bart'''			)
         self.assertIn('''Unknown option TRANSFORMERS_VERBOSITY=super-error'''       ,     cl.out			)

         # no need to restore as nothing was changed





   def 	__lowerCAmelCase							(	self			):
         # testing `logger.warning_advice()`
         transformers.utils.logging._reset_library_root_logger()

         _lowerCAmelCase 			=  logging.get_logger('''transformers.models.bart.tokenization_bart'''			)
         _lowerCAmelCase 			=  '''Testing 1, 2, 3'''

         with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='''1'''			):
               # nothing should be logged as env var disables this method
               with CaptureLogger(_lowerCAmelCase			) as cl:
                     logger.warning_advice(_lowerCAmelCase			)
               self.assertEqual(cl.out       ,     ''''''			)

         with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=''''''			):
               # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
               with CaptureLogger(_lowerCAmelCase			) as cl:
                     logger.warning_advice(_lowerCAmelCase			)
               self.assertEqual(cl.out       ,     msg + '''\n'''			)






def 							UpperCAmelCase__		(				)->Union[str, Any]:
      disable_progress_bar()
      assert are_progress_bars_disabled()

      enable_progress_bar()
      assert not are_progress_bars_disabled()




import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





class 		UpperCAmelCase						(						snake_case_       ,unittest.TestCase				):
   SCREAMING_SNAKE_CASE__							=     DiTPipeline
   SCREAMING_SNAKE_CASE__							=     CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
   SCREAMING_SNAKE_CASE__							=     PipelineTesterMixin.required_optional_params - {
       '''latents''',
       '''num_images_per_prompt''',
       '''callback''',
       '''callback_steps''',
   }
   SCREAMING_SNAKE_CASE__							=     CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
   SCREAMING_SNAKE_CASE__							=     False





   def 	__lowerCAmelCase							(	self			):
         torch.manual_seed(0			)
         _lowerCAmelCase 			=  TransformeraDModel(
             sample_size=16       ,     num_layers=2       ,     patch_size=4       ,     attention_head_dim=8       ,     num_attention_heads=2       ,     in_channels=4       ,     out_channels=8       ,     attention_bias=_lowerCAmelCase       ,     activation_fn='''gelu-approximate'''       ,     num_embeds_ada_norm=1_000       ,     norm_type='''ada_norm_zero'''       ,     norm_elementwise_affine=_lowerCAmelCase       ,     )
         _lowerCAmelCase 			=  AutoencoderKL()
         _lowerCAmelCase 			=  DDIMScheduler()
         _lowerCAmelCase 			=  {'''transformer''': transformer.eval(), '''vae''': vae.eval(), '''scheduler''': scheduler}
         return components





   def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase=0			):
         if str(_lowerCAmelCase			).startswith('''mps'''			):
               _lowerCAmelCase 			=  torch.manual_seed(_lowerCAmelCase			)
         else:
               _lowerCAmelCase 			=  torch.Generator(device=_lowerCAmelCase			).manual_seed(_lowerCAmelCase			)
         _lowerCAmelCase 			=  {
             '''class_labels''': [1],
             '''generator''': generator,
             '''num_inference_steps''': 2,
             '''output_type''': '''numpy''',
         }
         return inputs





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  '''cpu'''

         _lowerCAmelCase 			=  self.get_dummy_components()
         _lowerCAmelCase 			=  self.pipeline_class(**_lowerCAmelCase			)
         pipe.to(_lowerCAmelCase			)
         pipe.set_progress_bar_config(disable=_lowerCAmelCase			)

         _lowerCAmelCase 			=  self.get_dummy_inputs(_lowerCAmelCase			)
         _lowerCAmelCase 			=  pipe(**_lowerCAmelCase			).images
         _lowerCAmelCase 			=  image[0, -3:, -3:, -1]

         self.assertEqual(image.shape       ,     (1, 16, 16, 3)			)
         _lowerCAmelCase 			=  np.array([0.2_946, 0.6_601, 0.4_329, 0.3_296, 0.4_144, 0.5_319, 0.7_273, 0.5_013, 0.4_457]			)
         _lowerCAmelCase 			=  np.abs(image_slice.flatten() - expected_slice			).max()
         self.assertLessEqual(_lowerCAmelCase       ,     1E-3			)





   def 	__lowerCAmelCase							(	self			):
         self._test_inference_batch_single_identical(relax_max_difference=_lowerCAmelCase       ,     expected_max_diff=1E-3			)





   @unittest.skipIf(
       torch_device != '''cuda''' or not is_xformers_available()       ,     reason='''XFormers attention is only available with CUDA and `xformers` installed'''       ,     )
   def 	__lowerCAmelCase							(	self			):
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3			)






@require_torch_gpu
@slow
class 		UpperCAmelCase						(						unittest.TestCase				):





   def 	__lowerCAmelCase							(	self			):
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  torch.manual_seed(0			)

         _lowerCAmelCase 			=  DiTPipeline.from_pretrained('''facebook/DiT-XL-2-256'''			)
         pipe.to('''cuda'''			)

         _lowerCAmelCase 			=  ['''vase''', '''umbrella''', '''white shark''', '''white wolf''']
         _lowerCAmelCase 			=  pipe.get_label_ids(_lowerCAmelCase			)

         _lowerCAmelCase 			=  pipe(_lowerCAmelCase       ,     generator=_lowerCAmelCase       ,     num_inference_steps=40       ,     output_type='''np'''			).images

         for word, image in zip(_lowerCAmelCase       ,     _lowerCAmelCase			):
               _lowerCAmelCase 			=  load_numpy(
                   F'''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy'''			)
               assert np.abs((expected_image - image).max()			) < 1E-2





   def 	__lowerCAmelCase							(	self			):
         _lowerCAmelCase 			=  DiTPipeline.from_pretrained('''facebook/DiT-XL-2-512'''			)
         _lowerCAmelCase 			=  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config			)
         pipe.to('''cuda'''			)

         _lowerCAmelCase 			=  ['''vase''', '''umbrella''']
         _lowerCAmelCase 			=  pipe.get_label_ids(_lowerCAmelCase			)

         _lowerCAmelCase 			=  torch.manual_seed(0			)
         _lowerCAmelCase 			=  pipe(_lowerCAmelCase       ,     generator=_lowerCAmelCase       ,     num_inference_steps=25       ,     output_type='''np'''			).images

         for word, image in zip(_lowerCAmelCase       ,     _lowerCAmelCase			):
               _lowerCAmelCase 			=  load_numpy(
                   '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
                   F'''/dit/{word}_512.npy'''			)

               assert np.abs((expected_image - image).max()			) < 1E-1