






'''simple docstring'''


import tempfile
import unittest

from diffusers import (
    DDIMScheduler,
    DDPMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    PNDMScheduler,
    logging,
)
from diffusers.configuration_utils import ConfigMixin, register_to_config
from diffusers.utils.testing_utils import CaptureLogger




class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   'config.json'



   @register_to_config
   def __init__( self   ,   _A=2   ,   _A=5   ,   _A=(2, 5)   ,   _A="for diffusion"   ,   _A=[1, 3]   ,   )    ->   Dict:
    pass




class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   'config.json'



   @register_to_config
   def __init__( self   ,   _A=2   ,   _A=5   ,   _A=(2, 5)   ,   _A="for diffusion"   ,   _A=[1, 3]   ,   )    ->   Tuple:
    pass




class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   'config.json'



   @register_to_config
   def __init__( self   ,   _A=2   ,   _A=5   ,   _A=(2, 5)   ,   _A="for diffusion"   ,   _A=[1, 3]   ,   _A=[1, 3]   ,   )    ->   int:
    pass




class 							lowerCAmelCase					(							lowerCamelCase__   ):







   """simple docstring"""







   _A						=   'config.json'



   @register_to_config
   def __init__( self   ,   _A=2   ,   _A=5   ,   _A=(2, 5)   ,   _A="for diffusion"   ,   _A=[1, 5]   ,   _A=[5, 4]   ,   )    ->   List[str]:
    pass




class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   def    __magic_name__    ( self			)    ->   Optional[int]:
    with self.assertRaises(_A			):
     ConfigMixin.load_config('dummy_path'			)



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a    :	Any									=						SampleObject()
    __a    :	str									=						obj.config
    assert config["a"] == 2
    assert config["b"] == 5
    assert config["c"] == (2, 5)
    assert config["d"] == "for diffusion"
    assert config["e"] == [1, 3]

    # init ignore private arguments
    __a    :	Union[str, Any]									=						SampleObject(_name_or_path='lalala'			)
    __a    :	List[str]									=						obj.config
    assert config["a"] == 2
    assert config["b"] == 5
    assert config["c"] == (2, 5)
    assert config["d"] == "for diffusion"
    assert config["e"] == [1, 3]

    # can override default
    __a    :	Tuple									=						SampleObject(c=6			)
    __a    :	int									=						obj.config
    assert config["a"] == 2
    assert config["b"] == 5
    assert config["c"] == 6
    assert config["d"] == "for diffusion"
    assert config["e"] == [1, 3]

    # can use positional arguments.
    __a    :	str									=						SampleObject(1   ,   c=6			)
    __a    :	List[Any]									=						obj.config
    assert config["a"] == 1
    assert config["b"] == 5
    assert config["c"] == 6
    assert config["d"] == "for diffusion"
    assert config["e"] == [1, 3]



   def    __magic_name__    ( self			)    ->   Optional[Any]:
    __a    :	Union[str, Any]									=						SampleObject()
    __a    :	int									=						obj.config

    assert config["a"] == 2
    assert config["b"] == 5
    assert config["c"] == (2, 5)
    assert config["d"] == "for diffusion"
    assert config["e"] == [1, 3]

    with tempfile.TemporaryDirectory() as tmpdirname:
     obj.save_config(_A			)
     __a    :	Optional[Any]									=						SampleObject.from_config(SampleObject.load_config(_A			)			)
     __a    :	Dict									=						new_obj.config

    # unfreeze configs
    __a    :	str									=						dict(_A			)
    __a    :	Any									=						dict(_A			)

    assert config.pop('c'			) == (2, 5)  # instantiated as tuple
    assert new_config.pop('c'			) == [2, 5]  # saved & loaded as list because of json
    config.pop('_use_default_values'			)
    assert config == new_config



   def    __magic_name__    ( self			)    ->   Any:
    __a    :	Dict									=						logging.get_logger('diffusers.configuration_utils'			)
    # 30 for warning
    logger.setLevel(30			)

    with CaptureLogger(_A			) as cap_logger:
     __a    :	int									=						DDIMScheduler.from_pretrained(
         'hf-internal-testing/tiny-stable-diffusion-torch'   ,   subfolder='scheduler'			)

    assert ddim.__class__ == DDIMScheduler
    # no warning should be thrown
    assert cap_logger.out == ""



   def    __magic_name__    ( self			)    ->   Dict:
    __a    :	Any									=						logging.get_logger('diffusers.configuration_utils'			)
    # 30 for warning
    logger.setLevel(30			)

    with CaptureLogger(_A			) as cap_logger:
     __a    :	List[str]									=						EulerDiscreteScheduler.from_pretrained(
         'hf-internal-testing/tiny-stable-diffusion-torch'   ,   subfolder='scheduler'			)

    assert euler.__class__ == EulerDiscreteScheduler
    # no warning should be thrown
    assert cap_logger.out == ""



   def    __magic_name__    ( self			)    ->   Optional[Any]:
    __a    :	Any									=						logging.get_logger('diffusers.configuration_utils'			)
    # 30 for warning
    logger.setLevel(30			)

    with CaptureLogger(_A			) as cap_logger:
     __a    :	Union[str, Any]									=						EulerAncestralDiscreteScheduler.from_pretrained(
         'hf-internal-testing/tiny-stable-diffusion-torch'   ,   subfolder='scheduler'			)

    assert euler.__class__ == EulerAncestralDiscreteScheduler
    # no warning should be thrown
    assert cap_logger.out == ""



   def    __magic_name__    ( self			)    ->   List[Any]:
    __a    :	Optional[int]									=						logging.get_logger('diffusers.configuration_utils'			)
    # 30 for warning
    logger.setLevel(30			)

    with CaptureLogger(_A			) as cap_logger:
     __a    :	Optional[Any]									=						PNDMScheduler.from_pretrained(
         'hf-internal-testing/tiny-stable-diffusion-torch'   ,   subfolder='scheduler'			)

    assert pndm.__class__ == PNDMScheduler
    # no warning should be thrown
    assert cap_logger.out == ""



   def    __magic_name__    ( self			)    ->   str:
    __a    :	Optional[Any]									=						logging.get_logger('diffusers.configuration_utils'			)
    # 30 for warning
    logger.setLevel(30			)

    with CaptureLogger(_A			) as cap_logger:
     __a    :	Tuple									=						DDPMScheduler.from_pretrained(
         'hf-internal-testing/tiny-stable-diffusion-torch'   ,   subfolder='scheduler'   ,   prediction_type='sample'   ,   beta_end=8   ,   )

    with CaptureLogger(_A			) as cap_logger_a:
     __a    :	Tuple									=						DDPMScheduler.from_pretrained('google/ddpm-celebahq-256'   ,   beta_start=88			)

    assert ddpm.__class__ == DDPMScheduler
    assert ddpm.config.prediction_type == "sample"
    assert ddpm.config.beta_end == 8
    assert ddpm_a.config.beta_start == 88

    # no warning should be thrown
    assert cap_logger.out == ""
    assert cap_logger_a.out == ""



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a    :	Dict									=						logging.get_logger('diffusers.configuration_utils'			)
    # 30 for warning
    logger.setLevel(30			)

    with CaptureLogger(_A			) as cap_logger:
     __a    :	Any									=						DPMSolverMultistepScheduler.from_pretrained(
         'hf-internal-testing/tiny-stable-diffusion-torch'   ,   subfolder='scheduler'			)

    assert dpm.__class__ == DPMSolverMultistepScheduler
    # no warning should be thrown
    assert cap_logger.out == ""



   def    __magic_name__    ( self			)    ->   List[Any]:
    # let's first save a config that should be in the form
    #    a=2,
    #    b=5,
    #    c=(2, 5),
    #    d="for diffusion",
    #    e=[1, 3],

    __a    :	str									=						SampleObject()

    __a    :	str									=						{k: v for k, v in config.config.items() if not k.startswith('_'			)}

    # make sure that default config has all keys in `_use_default_values`
    assert set(config_dict.keys()			) == set(config.config._use_default_values			)

    with tempfile.TemporaryDirectory() as tmpdirname:
     config.save_config(_A			)

     # now loading it with SampleObject2 should put f into `_use_default_values`
     __a    :	List[str]									=						SampleObjecta.from_config(_A			)

     assert "f" in config._use_default_values
     assert config.f == [1, 3]

    # now loading the config, should **NOT** use [1, 3] for `f`, but the default [1, 4] value
    # **BECAUSE** it is part of `config._use_default_values`
    __a    :	List[str]									=						SampleObjecta.from_config(config.config			)
    assert new_config.f == [5, 4]

    config.config._use_default_values.pop()
    __a    :	Union[str, Any]									=						SampleObjecta.from_config(config.config			)
    assert new_config_a.f == [1, 3]

    # Nevertheless "e" should still be correctly loaded to [1, 3] from SampleObject2 instead of defaulting to [1, 5]
    assert new_config_a.e == [1, 3]












'''simple docstring'''


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
  import torch

if is_vision_available():
  from PIL import Image

  from transformers import TvltImageProcessor






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__=10       ,		SCREAMING_SNAKE_CASE__=10       ,		SCREAMING_SNAKE_CASE__=False       ,		SCREAMING_SNAKE_CASE__=False		):
 __a    :	Dict									=						[]
 for i in range(image_processor_tester.num_frames		):
  video.append(np.random.randint(255       ,		size=(image_processor_tester.num_channels, width, height)       ,		dtype=np.uinta		)		)

 if not numpify and not torchify:
  # PIL expects the channel dimension as last dimension
  __a    :	List[Any]									=						[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__       ,		0       ,		-1		)		) for frame in video]

 if torchify:
  __a    :	List[Any]									=						[torch.from_numpy(SCREAMING_SNAKE_CASE__		) for frame in video]

 return video






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__=False       ,		SCREAMING_SNAKE_CASE__=False       ,		SCREAMING_SNAKE_CASE__=False		):
 assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

 __a    :	Optional[int]									=						[]
 for i in range(image_processor_tester.batch_size		):
  if equal_resolution:
   __a    :	Dict									=						image_processor_tester.max_resolution
  else:
   __a			,    __a    :	Union[str, Any]									=						np.random.choice(
       np.arange(image_processor_tester.min_resolution       ,		image_processor_tester.max_resolution		)       ,		2		)
   __a    :	Any									=						prepare_video(
       image_processor_tester=SCREAMING_SNAKE_CASE__       ,		width=SCREAMING_SNAKE_CASE__       ,		height=SCREAMING_SNAKE_CASE__       ,		numpify=SCREAMING_SNAKE_CASE__       ,		torchify=SCREAMING_SNAKE_CASE__       ,		)
  video_inputs.append(SCREAMING_SNAKE_CASE__		)

 return video_inputs




class 							lowerCAmelCase					(							unittest.TestCase   ):







   """simple docstring"""







   def __init__( self   ,   _A   ,   _A=7   ,   _A=3   ,   _A=4   ,   _A=18   ,   _A=30   ,   _A=400   ,   _A=True   ,   _A=None   ,   _A=True   ,   _A=[0.5, 0.5, 0.5]   ,   _A=[0.5, 0.5, 0.5]   ,   _A=True   ,   _A=None   ,   )    ->   str:
    __a    :	Any									=						size if size is not None else {'shortest_edge': 18}
    __a    :	str									=						crop_size if crop_size is not None else {'height': 18, 'width': 18}

    __a    :	Any									=						parent
    __a    :	Tuple									=						batch_size
    __a    :	Any									=						num_channels
    __a    :	Union[str, Any]									=						num_frames
    __a    :	Optional[Any]									=						image_size
    __a    :	Any									=						min_resolution
    __a    :	List[str]									=						max_resolution
    __a    :	Any									=						do_resize
    __a    :	Dict									=						size
    __a    :	Optional[int]									=						do_normalize
    __a    :	Union[str, Any]									=						image_mean
    __a    :	List[Any]									=						image_std
    __a    :	Dict									=						do_center_crop
    __a    :	List[Any]									=						crop_size



   def    __magic_name__    ( self			)    ->   Any:
    return {
        "image_mean": self.image_mean,
        "image_std": self.image_std,
        "do_normalize": self.do_normalize,
        "do_resize": self.do_resize,
        "size": self.size,
        "do_center_crop": self.do_center_crop,
        "crop_size": self.crop_size,
    }




@require_torch
@require_vision
class 							lowerCAmelCase					(							lowerCamelCase__							,      unittest.TestCase   ):







   """simple docstring"""







   _A						=   TvltImageProcessor if is_vision_available() else None



   def    __magic_name__    ( self			)    ->   int:
    __a    :	List[Any]									=						TvltImageProcessorTester(self			)



   @property
   def    __magic_name__    ( self			)    ->   Optional[Any]:
    return self.image_processor_tester.prepare_image_processor_dict()



   def    __magic_name__    ( self			)    ->   Optional[int]:
    __a    :	Any									=						self.image_processing_class(**self.image_processor_dict			)
    self.assertTrue(hasattr(_A   ,   'image_mean'			)			)
    self.assertTrue(hasattr(_A   ,   'image_std'			)			)
    self.assertTrue(hasattr(_A   ,   'do_normalize'			)			)
    self.assertTrue(hasattr(_A   ,   'do_resize'			)			)
    self.assertTrue(hasattr(_A   ,   'do_center_crop'			)			)
    self.assertTrue(hasattr(_A   ,   'size'			)			)



   def    __magic_name__    ( self			)    ->   str:
    # Initialize image_processor
    __a    :	str									=						self.image_processing_class(**self.image_processor_dict			)
    # create random PIL videos
    __a    :	Optional[Any]									=						prepare_video_inputs(self.image_processor_tester   ,   equal_resolution=_A			)
    for video in video_inputs:
     self.assertIsInstance(_A   ,   _A			)
     self.assertIsInstance(video[0]   ,   Image.Image			)

    # Test not batched input
    __a    :	Tuple									=						image_processor(video_inputs[0]   ,   return_tensors='pt'			).pixel_values
    self.assertEqual(
        encoded_videos.shape   ,   (
            1,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )   ,   )

    # Test batched
    __a    :	Dict									=						image_processor(_A   ,   return_tensors='pt'			).pixel_values
    self.assertEqual(
        encoded_videos.shape   ,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )   ,   )



   def    __magic_name__    ( self			)    ->   Any:
    # Initialize image_processor
    __a    :	Union[str, Any]									=						self.image_processing_class(**self.image_processor_dict			)
    # create random numpy tensors
    __a    :	List[str]									=						prepare_video_inputs(self.image_processor_tester   ,   equal_resolution=_A   ,   numpify=_A			)
    for video in video_inputs:
     self.assertIsInstance(_A   ,   _A			)
     self.assertIsInstance(video[0]   ,   np.ndarray			)

    # Test not batched input
    __a    :	List[str]									=						image_processor(video_inputs[0]   ,   return_tensors='pt'			).pixel_values
    self.assertEqual(
        encoded_videos.shape   ,   (
            1,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )   ,   )

    # Test batched
    __a    :	Dict									=						image_processor(_A   ,   return_tensors='pt'			).pixel_values
    self.assertEqual(
        encoded_videos.shape   ,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )   ,   )



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    # Initialize image_processor
    __a    :	Optional[Any]									=						self.image_processing_class(**self.image_processor_dict			)
    # create random PyTorch tensors
    __a    :	Optional[Any]									=						prepare_video_inputs(self.image_processor_tester   ,   equal_resolution=_A   ,   torchify=_A			)
    for video in video_inputs:
     self.assertIsInstance(_A   ,   _A			)
     self.assertIsInstance(video[0]   ,   torch.Tensor			)

    # Test not batched input
    __a    :	Dict									=						image_processor(video_inputs[0]   ,   return_tensors='pt'			).pixel_values
    self.assertEqual(
        encoded_videos.shape   ,   (
            1,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )   ,   )

    # Test batched
    __a    :	Tuple									=						image_processor(_A   ,   return_tensors='pt'			).pixel_values
    self.assertEqual(
        encoded_videos.shape   ,   (
            self.image_processor_tester.batch_size,
            self.image_processor_tester.num_frames,
            self.image_processor_tester.num_channels,
            self.image_processor_tester.crop_size['height'],
            self.image_processor_tester.crop_size['width'],
        )   ,   )




