


import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np


class     __UpperCAmelCase							:


     """simple docstring"""


     def 	snake_case_  (	self    ):
        torch.manual_seed(0    )
        __a					=  TaEncoderModel.from_pretrained("""hf-internal-testing/tiny-random-t5"""    )

        torch.manual_seed(0    )
        __a					=  AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-t5"""    )

        torch.manual_seed(0    )
        __a					=  UNetaDConditionModel(
            sample_size=32  ,       layers_per_block=1  ,       block_out_channels=[32, 64]  ,       down_block_types=[
                """ResnetDownsampleBlock2D""",
                """SimpleCrossAttnDownBlock2D""",
            ]  ,       mid_block_type="""UNetMidBlock2DSimpleCrossAttn"""  ,       up_block_types=["""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""]  ,       in_channels=3  ,       out_channels=6  ,       cross_attention_dim=32  ,       encoder_hid_dim=32  ,       attention_head_dim=8  ,       addition_embed_type="""text"""  ,       addition_embed_type_num_heads=2  ,       cross_attention_norm="""group_norm"""  ,       resnet_time_scale_shift="""scale_shift"""  ,       act_fn="""gelu"""  ,       )
        unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

        torch.manual_seed(0    )
        __a					=  DDPMScheduler(
            num_train_timesteps=1000  ,       beta_schedule="""squaredcos_cap_v2"""  ,       beta_start=0.0001  ,       beta_end=0.02  ,       thresholding=__A  ,       dynamic_thresholding_ratio=0.95  ,       sample_max_value=1.0  ,       prediction_type="""epsilon"""  ,       variance_type="""learned_range"""  ,       )

        torch.manual_seed(0    )
        __a					=  IFWatermarker()

        return {
            "text_encoder": text_encoder,
            "tokenizer": tokenizer,
            "unet": unet,
            "scheduler": scheduler,
            "watermarker": watermarker,
            "safety_checker": None,
            "feature_extractor": None,
        }


     def 	snake_case_  (	self    ):
        torch.manual_seed(0    )
        __a					=  TaEncoderModel.from_pretrained("""hf-internal-testing/tiny-random-t5"""    )

        torch.manual_seed(0    )
        __a					=  AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-t5"""    )

        torch.manual_seed(0    )
        __a					=  UNetaDConditionModel(
            sample_size=32  ,       layers_per_block=[1, 2]  ,       block_out_channels=[32, 64]  ,       down_block_types=[
                """ResnetDownsampleBlock2D""",
                """SimpleCrossAttnDownBlock2D""",
            ]  ,       mid_block_type="""UNetMidBlock2DSimpleCrossAttn"""  ,       up_block_types=["""SimpleCrossAttnUpBlock2D""", """ResnetUpsampleBlock2D"""]  ,       in_channels=6  ,       out_channels=6  ,       cross_attention_dim=32  ,       encoder_hid_dim=32  ,       attention_head_dim=8  ,       addition_embed_type="""text"""  ,       addition_embed_type_num_heads=2  ,       cross_attention_norm="""group_norm"""  ,       resnet_time_scale_shift="""scale_shift"""  ,       act_fn="""gelu"""  ,       class_embed_type="""timestep"""  ,       mid_block_scale_factor=1.414  ,       time_embedding_act_fn="""gelu"""  ,       time_embedding_dim=32  ,       )
        unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

        torch.manual_seed(0    )
        __a					=  DDPMScheduler(
            num_train_timesteps=1000  ,       beta_schedule="""squaredcos_cap_v2"""  ,       beta_start=0.0001  ,       beta_end=0.02  ,       thresholding=__A  ,       dynamic_thresholding_ratio=0.95  ,       sample_max_value=1.0  ,       prediction_type="""epsilon"""  ,       variance_type="""learned_range"""  ,       )

        torch.manual_seed(0    )
        __a					=  DDPMScheduler(
            num_train_timesteps=1000  ,       beta_schedule="""squaredcos_cap_v2"""  ,       beta_start=0.0001  ,       beta_end=0.02  ,       )

        torch.manual_seed(0    )
        __a					=  IFWatermarker()

        return {
            "text_encoder": text_encoder,
            "tokenizer": tokenizer,
            "unet": unet,
            "scheduler": scheduler,
            "image_noising_scheduler": image_noising_scheduler,
            "watermarker": watermarker,
            "safety_checker": None,
            "feature_extractor": None,
        }


     def 	snake_case_  (	self    ):
        __a					=  self.get_dummy_components()
        __a					=  self.pipeline_class(**__A    )
        pipe.to(__A    )
        pipe.set_progress_bar_config(disable=__A    )

        __a					=  self.get_dummy_inputs(__A    )

        __a					=  inputs["""prompt"""]
        __a					=  inputs["""generator"""]
        __a					=  inputs["""num_inference_steps"""]
        __a					=  inputs["""output_type"""]

        if "image" in inputs:
           __a					=  inputs["""image"""]
        else:
           __a					=  None

        if "mask_image" in inputs:
           __a					=  inputs["""mask_image"""]
        else:
           __a					=  None

        if "original_image" in inputs:
           __a					=  inputs["""original_image"""]
        else:
           __a					=  None

        __a	,    __a					=  pipe.encode_prompt(__A    )

        # inputs with prompt converted to embeddings
        __a					=  {
            """prompt_embeds""": prompt_embeds,
            """negative_prompt_embeds""": negative_prompt_embeds,
            """generator""": generator,
            """num_inference_steps""": num_inference_steps,
            """output_type""": output_type,
        }

        if image is not None:
           __a					=  image

        if mask_image is not None:
           __a					=  mask_image

        if original_image is not None:
           __a					=  original_image

        # set all optional components to None
        for optional_component in pipe._optional_components:
           setattr(__A  ,       __A  ,       __A    )

        __a					=  pipe(**__A    )[0]

        with tempfile.TemporaryDirectory() as tmpdir:
           pipe.save_pretrained(__A    )
           __a					=  self.pipeline_class.from_pretrained(__A    )
           pipe_loaded.to(__A    )
           pipe_loaded.set_progress_bar_config(disable=__A    )

        pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

        for optional_component in pipe._optional_components:
           self.assertTrue(
               getattr(__A  ,       __A    ) is None  ,       f'''`{optional_component}` did not stay set to None after loading.'''  ,       )

        __a					=  self.get_dummy_inputs(__A    )

        __a					=  inputs["""generator"""]
        __a					=  inputs["""num_inference_steps"""]
        __a					=  inputs["""output_type"""]

        # inputs with prompt converted to embeddings
        __a					=  {
            """prompt_embeds""": prompt_embeds,
            """negative_prompt_embeds""": negative_prompt_embeds,
            """generator""": generator,
            """num_inference_steps""": num_inference_steps,
            """output_type""": output_type,
        }

        if image is not None:
           __a					=  image

        if mask_image is not None:
           __a					=  mask_image

        if original_image is not None:
           __a					=  original_image

        __a					=  pipe_loaded(**__A    )[0]

        __a					=  np.abs(to_np(__A    ) - to_np(__A    )    ).max()
        self.assertLess(__A  ,       1E-4    )


     def 	snake_case_  (	self    ):
        __a					=  self.get_dummy_components()
        __a					=  self.pipeline_class(**__A    )
        pipe.to(__A    )
        pipe.set_progress_bar_config(disable=__A    )

        __a					=  self.get_dummy_inputs(__A    )
        __a					=  pipe(**__A    )[0]

        with tempfile.TemporaryDirectory() as tmpdir:
           pipe.save_pretrained(__A    )
           __a					=  self.pipeline_class.from_pretrained(__A    )
           pipe_loaded.to(__A    )
           pipe_loaded.set_progress_bar_config(disable=__A    )

        pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()    )  # For reproducibility tests

        __a					=  self.get_dummy_inputs(__A    )
        __a					=  pipe_loaded(**__A    )[0]

        __a					=  np.abs(to_np(__A    ) - to_np(__A    )    ).max()
        self.assertLess(__A  ,       1E-4    )







from collections.abc import Callable




def  a   (lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__   ):
   __a					=  a
   __a					=  b
   if function(lowerCAmelCase__   ) == 0:  # one of the a or b is a root for the function
      return a
   elif function(lowerCAmelCase__   ) == 0:
      return b
   elif (
       function(lowerCAmelCase__   ) * function(lowerCAmelCase__   ) > 0
   ):  # if none of these are root and they are both positive or negative,
      # then this algorithm can't find the root
      raise ValueError("""could not find root in given interval."""   )
   else:
      __a					=  start + (end - start) / 2.0
      while abs(start - mid   ) > 10**-7:  # until precisely equals to 10^-7
         if function(lowerCAmelCase__   ) == 0:
            return mid
         elif function(lowerCAmelCase__   ) * function(lowerCAmelCase__   ) < 0:
            __a					=  mid
         else:
            __a					=  mid
         __a					=  start + (end - start) / 2.0
      return mid




def  a   (lowerCAmelCase__   ):
   return x**3 - 2 * x - 5


if __name__ == "__main__":
  print(bisection(f, 1, 1_0_0_0))

  import doctest

  doctest.testmod()



