


'''simple docstring'''
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoImageProcessor, ViTImageProcessor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


UpperCamelCase__ =			get_tests_dir('fixtures')


class        _UpperCAmelCase						(		unittest.TestCase			):




    def 				lowerCAmelCase__				(			self  :       Union[str, Any]			):






       '''simple docstring'''






       lowercase_	:    Any           =     mock.Mock()
       lowercase_	:    Optional[int]           =     5_0_0
       lowercase_	:    Union[str, Any]           =     {}
       lowercase_	:    Optional[int]           =     HTTPError
       lowercase_	:    Dict           =     {}

       # Download this model to make sure it's in the cache.
       lowercase_	:    Optional[Any]           =     ViTImageProcessor.from_pretrained("hf-internal-testing/tiny-random-vit"			)
       # Under the mock environment we get a 500 error when trying to reach the model.
       with mock.patch("requests.Session.request"  ,     return_value=a			) as mock_head:
          lowercase_	:    Any           =     ViTImageProcessor.from_pretrained("hf-internal-testing/tiny-random-vit"			)
          # This check we did call the fake head request
          mock_head.assert_called()




    def 				lowerCAmelCase__				(			self  :       str			):






       '''simple docstring'''






       lowercase_	:    Tuple           =     ViTImageProcessor.from_pretrained(
           "https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json"			)





    def 				lowerCAmelCase__				(			self  :       str			):






       '''simple docstring'''






       with self.assertRaises(a			):
          # config is in subfolder, the following should not work without specifying the subfolder
          lowercase_	:    int           =     AutoImageProcessor.from_pretrained("hf-internal-testing/stable-diffusion-all-variants"			)

       lowercase_	:    Optional[Any]           =     AutoImageProcessor.from_pretrained(
           "hf-internal-testing/stable-diffusion-all-variants"  ,     subfolder="feature_extractor"			)

       self.assertIsNotNone(a			)


@is_staging_test
class        _UpperCAmelCase						(		unittest.TestCase			):




    @classmethod
    def 				lowerCAmelCase__				(			cls  :       Optional[int]			):






       '''simple docstring'''






       lowercase_	:    Union[str, Any]           =     TOKEN
       HfFolder.save_token(a			)




    @classmethod
    def 				lowerCAmelCase__				(			cls  :       List[Any]			):






       '''simple docstring'''






       try:
          delete_repo(token=cls._token  ,     repo_id="test-image-processor"			)
       except HTTPError:
          pass

       try:
          delete_repo(token=cls._token  ,     repo_id="valid_org/test-image-processor-org"			)
       except HTTPError:
          pass

       try:
          delete_repo(token=cls._token  ,     repo_id="test-dynamic-image-processor"			)
       except HTTPError:
          pass




    def 				lowerCAmelCase__				(			self  :       Any			):






       '''simple docstring'''






       lowercase_	:    int           =     ViTImageProcessor.from_pretrained(a			)
       image_processor.push_to_hub("test-image-processor"  ,     use_auth_token=self._token			)

       lowercase_	:    Optional[int]           =     ViTImageProcessor.from_pretrained(f"""{USER}/test-image-processor"""			)
       for k, v in image_processor.__dict__.items():
          self.assertEqual(a  ,     getattr(a  ,     a			)			)

       # Reset repo
       delete_repo(token=self._token  ,     repo_id="test-image-processor"			)

       # Push to hub via save_pretrained
       with tempfile.TemporaryDirectory() as tmp_dir:
          image_processor.save_pretrained(
              a  ,     repo_id="test-image-processor"  ,     push_to_hub=a  ,     use_auth_token=self._token			)

       lowercase_	:    str           =     ViTImageProcessor.from_pretrained(f"""{USER}/test-image-processor"""			)
       for k, v in image_processor.__dict__.items():
          self.assertEqual(a  ,     getattr(a  ,     a			)			)




    def 				lowerCAmelCase__				(			self  :       Optional[int]			):






       '''simple docstring'''






       lowercase_	:    Union[str, Any]           =     ViTImageProcessor.from_pretrained(a			)
       image_processor.push_to_hub("valid_org/test-image-processor"  ,     use_auth_token=self._token			)

       lowercase_	:    Any           =     ViTImageProcessor.from_pretrained("valid_org/test-image-processor"			)
       for k, v in image_processor.__dict__.items():
          self.assertEqual(a  ,     getattr(a  ,     a			)			)

       # Reset repo
       delete_repo(token=self._token  ,     repo_id="valid_org/test-image-processor"			)

       # Push to hub via save_pretrained
       with tempfile.TemporaryDirectory() as tmp_dir:
          image_processor.save_pretrained(
              a  ,     repo_id="valid_org/test-image-processor-org"  ,     push_to_hub=a  ,     use_auth_token=self._token			)

       lowercase_	:    Dict           =     ViTImageProcessor.from_pretrained("valid_org/test-image-processor-org"			)
       for k, v in image_processor.__dict__.items():
          self.assertEqual(a  ,     getattr(a  ,     a			)			)





    def 				lowerCAmelCase__				(			self  :       Any			):






       '''simple docstring'''






       CustomImageProcessor.register_for_auto_class()
       lowercase_	:    List[str]           =     CustomImageProcessor.from_pretrained(a			)

       image_processor.push_to_hub("test-dynamic-image-processor"  ,     use_auth_token=self._token			)

       # This has added the proper auto_map field to the config
       self.assertDictEqual(
           image_processor.auto_map  ,     {"AutoImageProcessor": "custom_image_processing.CustomImageProcessor"}  ,     )

       lowercase_	:    Union[str, Any]           =     AutoImageProcessor.from_pretrained(
           f"""{USER}/test-dynamic-image-processor"""  ,     trust_remote_code=a			)
       # Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
       self.assertEqual(new_image_processor.__class__.__name__  ,     "CustomImageProcessor"			)












'''simple docstring'''
import importlib
import math
import os
from dataclasses import dataclass
from enum import Enum
from typing import Any, Dict, Optional, Tuple, Union

import flax
import jax.numpy as jnp

from ..utils import BaseOutput


UpperCamelCase__ =			'scheduler_config.json'


class        _UpperCAmelCase						(		snake_case			):
    __lowerCamelCase:   int		       =    1
    __lowerCamelCase:   List[Any]		       =    2
    __lowerCamelCase:   Optional[Any]		       =    3
    __lowerCamelCase:   int		       =    4
    __lowerCamelCase:   Optional[int]		       =    5


@dataclass
class        _UpperCAmelCase						(		snake_case			):
    __lowerCamelCase:   jnp.ndarray


class        _UpperCAmelCase						:
    __lowerCamelCase:   List[str]		       =    SCHEDULER_CONFIG_NAME
    __lowerCamelCase:   Optional[int]		       =    ['dtype']
    __lowerCamelCase:   int		       =    []
    __lowerCamelCase:   Dict		       =    True




    @classmethod
    def 				lowerCAmelCase__				(			cls  :       Tuple  ,     a  :       Dict[str, Any] = None  ,     a  :       Optional[str] = None  ,     a  :       Union[str, Any]=False  ,     **a  :       Union[str, Any]  ,     ):






       '''simple docstring'''






       lowercase_    ,		lowercase_	:    Any           =     cls.load_config(
           pretrained_model_name_or_path=a  ,     subfolder=a  ,     return_unused_kwargs=a  ,     **a  ,     )
       lowercase_    ,		lowercase_	:    Union[str, Any]           =     cls.from_config(a  ,     return_unused_kwargs=a  ,     **a			)

       if hasattr(a  ,     "create_state"			) and getattr(a  ,     "has_state"  ,     a			):
          lowercase_	:    Tuple           =     scheduler.create_state()

       if return_unused_kwargs:
          return scheduler, state, unused_kwargs

       return scheduler, state




    def 				lowerCAmelCase__				(			self  :       int  ,     a  :       Union[str, os.PathLike]  ,     a  :       bool = False  ,     **a  :       int			):






       '''simple docstring'''






       self.save_config(save_directory=a  ,     push_to_hub=a  ,     **a			)




    @property
    def 				lowerCAmelCase__				(			self  :       Tuple			):






       '''simple docstring'''






       return self._get_compatibles()





    @classmethod
    def 				lowerCAmelCase__				(			cls  :       Dict			):






       '''simple docstring'''






       lowercase_	:    str           =     list(set([cls.__name__] + cls._compatibles			)			)
       lowercase_	:    str           =     importlib.import_module(__name__.split("."			)[0]			)
       lowercase_	:    Optional[Any]           =     [
           getattr(a  ,     a			) for c in compatible_classes_str if hasattr(a  ,     a			)
       ]
       return compatible_classes




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   assert len(_UpperCamelCase							) >= x.ndim
   return jnp.broadcast_to(x.reshape(x.shape + (1,) * (len(_UpperCamelCase							) - x.ndim)							)						,		_UpperCamelCase							)




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase=0.999						,		_UpperCamelCase=jnp.floataa							):


   """simple docstring"""




   def alpha_bar(_UpperCamelCase							):
      return math.cos((time_step + 0.008) / 1.008 * math.pi / 2							) ** 2

   lowercase_	:    int           =     []
   for i in range(_UpperCamelCase							):
      lowercase_	:    Union[str, Any]           =     i / num_diffusion_timesteps
      lowercase_	:    Dict           =     (i + 1) / num_diffusion_timesteps
      betas.append(min(1 - alpha_bar(_UpperCamelCase							) / alpha_bar(_UpperCamelCase							)						,		_UpperCamelCase							)							)
   return jnp.array(_UpperCamelCase						,		dtype=_UpperCamelCase							)


@flax.struct.dataclass
class        _UpperCAmelCase						:
    __lowerCamelCase:   jnp.ndarray
    __lowerCamelCase:   jnp.ndarray
    __lowerCamelCase:   jnp.ndarray




    @classmethod
    def 				lowerCAmelCase__				(			cls  :       Tuple  ,     a  :       Optional[int]			):






       '''simple docstring'''






       lowercase_	:    Any           =     scheduler.config

       if config.trained_betas is not None:
          lowercase_	:    Union[str, Any]           =     jnp.asarray(config.trained_betas  ,     dtype=scheduler.dtype			)
       elif config.beta_schedule == "linear":
          lowercase_	:    List[Any]           =     jnp.linspace(config.beta_start  ,     config.beta_end  ,     config.num_train_timesteps  ,     dtype=scheduler.dtype			)
       elif config.beta_schedule == "scaled_linear":
          # this schedule is very specific to the latent diffusion model.
          lowercase_	:    Tuple           =     (
              jnp.linspace(
                  config.beta_start**0.5  ,     config.beta_end**0.5  ,     config.num_train_timesteps  ,     dtype=scheduler.dtype			)
              ** 2
          )
       elif config.beta_schedule == "squaredcos_cap_v2":
          # Glide cosine schedule
          lowercase_	:    Union[str, Any]           =     betas_for_alpha_bar(config.num_train_timesteps  ,     dtype=scheduler.dtype			)
       else:
          raise NotImplementedError(
              f"""beta_schedule {config.beta_schedule} is not implemented for scheduler {scheduler.__class__.__name__}"""			)

       lowercase_	:    str           =     1.0 - betas

       lowercase_	:    Dict           =     jnp.cumprod(a  ,     axis=0			)

       return cls(
           alphas=a  ,     betas=a  ,     alphas_cumprod=a  ,     )




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_	:    List[str]           =     state.alphas_cumprod

   lowercase_	:    Optional[Any]           =     alphas_cumprod[timesteps] ** 0.5
   lowercase_	:    int           =     sqrt_alpha_prod.flatten()
   lowercase_	:    Union[str, Any]           =     broadcast_to_shape_from_left(_UpperCamelCase						,		original_samples.shape							)

   lowercase_	:    Optional[int]           =     (1 - alphas_cumprod[timesteps]) ** 0.5
   lowercase_	:    Union[str, Any]           =     sqrt_one_minus_alpha_prod.flatten()
   lowercase_	:    Any           =     broadcast_to_shape_from_left(_UpperCamelCase						,		original_samples.shape							)

   return sqrt_alpha_prod, sqrt_one_minus_alpha_prod




def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_    ,		lowercase_	:    int           =     get_sqrt_alpha_prod(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
   lowercase_	:    str           =     sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise
   return noisy_samples





def 		__SCREAMING_SNAKE_CASE					(  _UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							):


   """simple docstring"""




   lowercase_    ,		lowercase_	:    int           =     get_sqrt_alpha_prod(_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase						,		_UpperCamelCase							)
   lowercase_	:    Any           =     sqrt_alpha_prod * noise - sqrt_one_minus_alpha_prod * sample
   return velocity




