



"""simple docstring"""




import json

import requests

from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info


def   lowercase__     (			_UpperCAmelCase				)     ->			Any:






      '''simple docstring'''


      class   a__		:


         def __init__(							self      :							int,     lowerCAmelCase      :							List[Any]			)    ->       None:
               assert isinstance(lowerCAmelCase,     (bytes, str)			)
               lowercase  :      Any					=   content






         def        lowercase				(							self      :							Tuple			)    ->       Optional[int]:
               return json.loads(self.content			)

      def mock_response(*_UpperCAmelCase	,      **_UpperCAmelCase				):
            assert args[0] == AUTHENTICATED_USER_ENDPOINT
            assert "Authorization" in kwargs["headers"]
            assert kwargs["headers"]["Authorization"].startswith('token '				)
            assert "Accept" in kwargs["headers"]
            return FakeResponse(B'{"login":"test","id":1}'				)

      monkeypatch.setattr(_UpperCAmelCase	,      'get'	,      _UpperCAmelCase				)
      lowercase  :      Tuple					=   fetch_github_info('token'				)
      assert result["login"] == "test"
      assert result["id"] == 1





"""simple docstring"""




import torch

from diffusers import HeunDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest


class   a__		(						SCREAMING_SNAKE_CASE__     ):
   _lowerCamelCase												=				(HeunDiscreteScheduler,)
   _lowerCamelCase												=				10


   def        lowercase				(							self      :							List[Any],     **lowerCAmelCase      :							Optional[int]			)    ->       Dict:
         lowercase  :      List[Any]					=   {
             'num_train_timesteps': 1100,
             'beta_start': 0.0001,
             'beta_end': 0.02,
             'beta_schedule': 'linear',
         }

         config.update(**lowerCAmelCase			)
         return config


   def        lowercase				(							self      :							Any			)    ->       Union[str, Any]:
         for timesteps in [10, 50, 100, 1000]:
               self.check_over_configs(num_train_timesteps=lowerCAmelCase			)


   def        lowercase				(							self      :							Any			)    ->       Any:
         for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001],     [0.0002, 0.002, 0.02]			):
               self.check_over_configs(beta_start=lowerCAmelCase,     beta_end=lowerCAmelCase			)


   def        lowercase				(							self      :							Union[str, Any]			)    ->       Any:
         for schedule in ["linear", "scaled_linear", "exp"]:
               self.check_over_configs(beta_schedule=lowerCAmelCase			)


   def        lowercase				(							self      :							Optional[int]			)    ->       Dict:
         for clip_sample_range in [1.0, 2.0, 3.0]:
               self.check_over_configs(clip_sample_range=lowerCAmelCase,     clip_sample=lowerCAmelCase			)


   def        lowercase				(							self      :							Dict			)    ->       Union[str, Any]:
         for prediction_type in ["epsilon", "v_prediction", "sample"]:
               self.check_over_configs(prediction_type=lowerCAmelCase			)


   def        lowercase				(							self      :							str			)    ->       Tuple:
         lowercase  :      Tuple					=   self.scheduler_classes[0]
         lowercase  :      int					=   self.get_scheduler_config()
         lowercase  :      str					=   scheduler_class(**lowerCAmelCase			)

         scheduler.set_timesteps(self.num_inference_steps			)

         lowercase  :      Tuple					=   self.dummy_model()
         lowercase  :      Dict					=   self.dummy_sample_deter * scheduler.init_noise_sigma
         lowercase  :      Optional[Any]					=   sample.to(lowerCAmelCase			)

         for i, t in enumerate(scheduler.timesteps			):
               lowercase  :      Any					=   scheduler.scale_model_input(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      Union[str, Any]					=   model(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      List[str]					=   scheduler.step(lowerCAmelCase,     lowerCAmelCase,     lowerCAmelCase			)
               lowercase  :      Tuple					=   output.prev_sample

         lowercase  :      Tuple					=   torch.sum(torch.abs(lowerCAmelCase			)			)
         lowercase  :      Dict					=   torch.mean(torch.abs(lowerCAmelCase			)			)

         if torch_device in ["cpu", "mps"]:
               assert abs(result_sum.item() - 0.1233			) < 1e-2
               assert abs(result_mean.item() - 0.0002			) < 1e-3
         else:
               # CUDA
               assert abs(result_sum.item() - 0.1233			) < 1e-2
               assert abs(result_mean.item() - 0.0002			) < 1e-3


   def        lowercase				(							self      :							Tuple			)    ->       List[str]:
         lowercase  :      str					=   self.scheduler_classes[0]
         lowercase  :      Any					=   self.get_scheduler_config(prediction_type='v_prediction'			)
         lowercase  :      List[str]					=   scheduler_class(**lowerCAmelCase			)

         scheduler.set_timesteps(self.num_inference_steps			)

         lowercase  :      List[Any]					=   self.dummy_model()
         lowercase  :      List[Any]					=   self.dummy_sample_deter * scheduler.init_noise_sigma
         lowercase  :      str					=   sample.to(lowerCAmelCase			)

         for i, t in enumerate(scheduler.timesteps			):
               lowercase  :      List[str]					=   scheduler.scale_model_input(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      List[Any]					=   model(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      List[str]					=   scheduler.step(lowerCAmelCase,     lowerCAmelCase,     lowerCAmelCase			)
               lowercase  :      Any					=   output.prev_sample

         lowercase  :      Dict					=   torch.sum(torch.abs(lowerCAmelCase			)			)
         lowercase  :      List[str]					=   torch.mean(torch.abs(lowerCAmelCase			)			)

         if torch_device in ["cpu", "mps"]:
               assert abs(result_sum.item() - 4.6934e-07			) < 1e-2
               assert abs(result_mean.item() - 6.1112e-10			) < 1e-3
         else:
               # CUDA
               assert abs(result_sum.item() - 4.693_4286_5017_0972e-07			) < 1e-2
               assert abs(result_mean.item() - 0.0002			) < 1e-3


   def        lowercase				(							self      :							Optional[Any]			)    ->       Tuple:
         lowercase  :      Optional[int]					=   self.scheduler_classes[0]
         lowercase  :      Optional[int]					=   self.get_scheduler_config()
         lowercase  :      Dict					=   scheduler_class(**lowerCAmelCase			)

         scheduler.set_timesteps(self.num_inference_steps,     device=lowerCAmelCase			)

         lowercase  :      int					=   self.dummy_model()
         lowercase  :      Tuple					=   self.dummy_sample_deter.to(lowerCAmelCase			) * scheduler.init_noise_sigma

         for t in scheduler.timesteps:
               lowercase  :      Optional[Any]					=   scheduler.scale_model_input(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      Optional[Any]					=   model(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      List[str]					=   scheduler.step(lowerCAmelCase,     lowerCAmelCase,     lowerCAmelCase			)
               lowercase  :      Optional[int]					=   output.prev_sample

         lowercase  :      str					=   torch.sum(torch.abs(lowerCAmelCase			)			)
         lowercase  :      Dict					=   torch.mean(torch.abs(lowerCAmelCase			)			)

         if str(lowerCAmelCase			).startswith('cpu'			):
               # The following sum varies between 148 and 156 on mps. Why?
               assert abs(result_sum.item() - 0.1233			) < 1e-2
               assert abs(result_mean.item() - 0.0002			) < 1e-3
         elif str(lowerCAmelCase			).startswith('mps'			):
               # Larger tolerance on mps
               assert abs(result_mean.item() - 0.0002			) < 1e-2
         else:
               # CUDA
               assert abs(result_sum.item() - 0.1233			) < 1e-2
               assert abs(result_mean.item() - 0.0002			) < 1e-3






   def        lowercase				(							self      :							Optional[Any]			)    ->       List[Any]:
         lowercase  :      str					=   self.scheduler_classes[0]
         lowercase  :      str					=   self.get_scheduler_config()
         lowercase  :      Tuple					=   scheduler_class(**lowerCAmelCase,     use_karras_sigmas=lowerCAmelCase			)

         scheduler.set_timesteps(self.num_inference_steps,     device=lowerCAmelCase			)

         lowercase  :      Dict					=   self.dummy_model()
         lowercase  :      Any					=   self.dummy_sample_deter.to(lowerCAmelCase			) * scheduler.init_noise_sigma
         lowercase  :      str					=   sample.to(lowerCAmelCase			)

         for t in scheduler.timesteps:
               lowercase  :      int					=   scheduler.scale_model_input(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      Optional[Any]					=   model(lowerCAmelCase,     lowerCAmelCase			)

               lowercase  :      int					=   scheduler.step(lowerCAmelCase,     lowerCAmelCase,     lowerCAmelCase			)
               lowercase  :      str					=   output.prev_sample

         lowercase  :      Dict					=   torch.sum(torch.abs(lowerCAmelCase			)			)
         lowercase  :      Union[str, Any]					=   torch.mean(torch.abs(lowerCAmelCase			)			)

         assert abs(result_sum.item() - 0.0_0015			) < 1e-2
         assert abs(result_mean.item() - 1.9869_5545_3503_4695e-07			) < 1e-2
