


"""simple docstring"""





import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()



class 		snake_case_(							a__				,       unittest.TestCase      ):
     __UpperCamelCase	=       KandinskyPriorPipeline
     __UpperCamelCase	=       ['''prompt''']
     __UpperCamelCase	=       ['''prompt''', '''negative_prompt''']
     __UpperCamelCase	=       [
         '''num_images_per_prompt''',
         '''generator''',
         '''num_inference_steps''',
         '''latents''',
         '''negative_prompt''',
         '''guidance_scale''',
         '''output_type''',
         '''return_dict''',
     ]
     __UpperCamelCase	=       False






     @property
     def   lowerCamelCase__  (						self	:       Dict					):
           return 3_2






     @property
     def   lowerCamelCase__  (						self	:       Optional[Any]					):
           return 3_2






     @property
     def   lowerCamelCase__  (						self	:       Tuple					):
           return self.time_input_dim






     @property
     def   lowerCamelCase__  (						self	:       List[Any]					):
           return self.time_input_dim * 4






     @property
     def   lowerCamelCase__  (						self	:       int					):
           return 1_0_0






     @property
     def   lowerCamelCase__  (						self	:       Optional[int]					):
           lowerCAmelCase       :						str							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)
           return tokenizer






     @property
     def   lowerCamelCase__  (						self	:       Dict					):
           torch.manual_seed(0					)
           lowerCAmelCase       :						Union[str, Any]							= CLIPTextConfig(
               bos_token_id=0       ,					eos_token_id=2       ,					hidden_size=self.text_embedder_hidden_size       ,					projection_dim=self.text_embedder_hidden_size       ,					intermediate_size=3_7       ,					layer_norm_eps=1E-05       ,					num_attention_heads=4       ,					num_hidden_layers=5       ,					pad_token_id=1       ,					vocab_size=1_0_0_0       ,					)
           return CLIPTextModelWithProjection(UpperCamelCase_					)






     @property
     def   lowerCamelCase__  (						self	:       List[Any]					):
           torch.manual_seed(0					)

           lowerCAmelCase       :						str							= {
               '''num_attention_heads''': 2,
               '''attention_head_dim''': 1_2,
               '''embedding_dim''': self.text_embedder_hidden_size,
               '''num_layers''': 1,
           }

           lowerCAmelCase       :						List[Any]							= PriorTransformer(**UpperCamelCase_					)
           # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
           lowerCAmelCase       :						Union[str, Any]							= nn.Parameter(torch.ones(model.clip_std.shape					)					)
           return model






     @property
     def   lowerCamelCase__  (						self	:       Optional[int]					):
           torch.manual_seed(0					)
           lowerCAmelCase       :						Optional[Any]							= CLIPVisionConfig(
               hidden_size=self.text_embedder_hidden_size       ,					image_size=2_2_4       ,					projection_dim=self.text_embedder_hidden_size       ,					intermediate_size=3_7       ,					num_attention_heads=4       ,					num_channels=3       ,					num_hidden_layers=5       ,					patch_size=1_4       ,					)

           lowerCAmelCase       :						Dict							= CLIPVisionModelWithProjection(UpperCamelCase_					)
           return model






     @property
     def   lowerCamelCase__  (						self	:       Dict					):
           lowerCAmelCase       :						Optional[int]							= CLIPImageProcessor(
               crop_size=2_2_4       ,					do_center_crop=UpperCamelCase_       ,					do_normalize=UpperCamelCase_       ,					do_resize=UpperCamelCase_       ,					image_mean=[0.48_145_466, 0.4_578_275, 0.40_821_073]       ,					image_std=[0.26_862_954, 0.26_130_258, 0.27_577_711]       ,					resample=3       ,					size=2_2_4       ,					)

           return image_processor






     def   lowerCamelCase__  (						self	:       Union[str, Any]					):
           lowerCAmelCase       :						List[str]							= self.dummy_prior
           lowerCAmelCase       :						str							= self.dummy_image_encoder
           lowerCAmelCase       :						Optional[Any]							= self.dummy_text_encoder
           lowerCAmelCase       :						Tuple							= self.dummy_tokenizer
           lowerCAmelCase       :						Tuple							= self.dummy_image_processor

           lowerCAmelCase       :						List[Any]							= UnCLIPScheduler(
               variance_type='''fixed_small_log'''       ,					prediction_type='''sample'''       ,					num_train_timesteps=1_0_0_0       ,					clip_sample=UpperCamelCase_       ,					clip_sample_range=10.0       ,					)

           lowerCAmelCase       :						Dict							= {
               '''prior''': prior,
               '''image_encoder''': image_encoder,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''scheduler''': scheduler,
               '''image_processor''': image_processor,
           }

           return components






     def   lowerCamelCase__  (						self	:       Optional[Any]       ,					UpperCamelCase_	:       int       ,					UpperCamelCase_	:       int=0					):
           if str(UpperCamelCase_					).startswith('''mps'''					):
                 lowerCAmelCase       :						Union[str, Any]							= torch.manual_seed(UpperCamelCase_					)
           else:
                 lowerCAmelCase       :						Tuple							= torch.Generator(device=UpperCamelCase_					).manual_seed(UpperCamelCase_					)
           lowerCAmelCase       :						Any							= {
               '''prompt''': '''horse''',
               '''generator''': generator,
               '''guidance_scale''': 4.0,
               '''num_inference_steps''': 2,
               '''output_type''': '''np''',
           }
           return inputs






     def   lowerCamelCase__  (						self	:       str					):
           lowerCAmelCase       :						Tuple							= '''cpu'''

           lowerCAmelCase       :						Optional[Any]							= self.get_dummy_components()

           lowerCAmelCase       :						int							= self.pipeline_class(**UpperCamelCase_					)
           lowerCAmelCase       :						List[str]							= pipe.to(UpperCamelCase_					)

           pipe.set_progress_bar_config(disable=UpperCamelCase_					)

           lowerCAmelCase       :						str							= pipe(**self.get_dummy_inputs(UpperCamelCase_					)					)
           lowerCAmelCase       :						Union[str, Any]							= output.image_embeds

           lowerCAmelCase       :						Optional[int]							= pipe(
               **self.get_dummy_inputs(UpperCamelCase_					)       ,					return_dict=UpperCamelCase_       ,					)[0]

           lowerCAmelCase       :						Any							= image[0, -1_0:]
           lowerCAmelCase       :						Any							= image_from_tuple[0, -1_0:]

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

           lowerCAmelCase       :						Union[str, Any]							= np.array(
               [-0.0_532, 1.7_120, 0.3_656, -1.0_852, -0.8_946, -1.1_756, 0.4_348, 0.2_482, 0.5_146, -0.1_156]					)

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






     @skip_mps
     def   lowerCamelCase__  (						self	:       Any					):
           lowerCAmelCase       :						Optional[int]							= torch_device == '''cpu'''
           lowerCAmelCase       :						Tuple							= True
           lowerCAmelCase       :						Optional[Any]							= False

           self._test_inference_batch_single_identical(
               test_max_difference=UpperCamelCase_       ,					relax_max_difference=UpperCamelCase_       ,					test_mean_pixel_difference=UpperCamelCase_       ,					)






     @skip_mps
     def   lowerCamelCase__  (						self	:       List[Any]					):
           lowerCAmelCase       :						List[str]							= torch_device == '''cpu'''
           lowerCAmelCase       :						Union[str, Any]							= False

           self._test_attention_slicing_forward_pass(
               test_max_difference=UpperCamelCase_       ,					test_mean_pixel_difference=UpperCamelCase_       ,					)






"""simple docstring"""





from collections.abc import Callable

snake_case__		:  Optional[int]     					=					Callable[[float], float]  # type alias for a real -> real function


def   _snake_case    (    _snake_case					:      RealFunc			, _snake_case					:      RealFunc			, _snake_case					:      int			, ):
      lowerCAmelCase       :						Dict							= float(_snake_case      )
      while True:
            try:
                  lowerCAmelCase       :						Optional[Any]							= prev_guess - function(_snake_case      ) / derivative(_snake_case      )
            except ZeroDivisionError:
                  raise ZeroDivisionError('''Could not find root'''      ) from None
            if abs(prev_guess - next_guess      ) < 10**-5:
                  return next_guess
            lowerCAmelCase       :						Optional[int]							= next_guess


def   _snake_case    (    _snake_case					:      float      ):
      return (x**3) - (2 * x) - 5


def   _snake_case    (    _snake_case					:      float      ):
      return 3 * (x**2) - 2


if __name__ == "__main__":
 print(newton(f, fa, 3))


