
'''simple docstring'''
def 							A_  (    __SCREAMING_SNAKE_CASE    :	Any      ,  __SCREAMING_SNAKE_CASE    :	Tuple = 1000			)					->							str:





  """simple docstring"""

  if (not isinstance(__lowerCamelCase      ,  __lowerCamelCase			)) or (digit_position <= 0):
    raise ValueError("""Digit position must be a positive integer"""			)
  elif (not isinstance(__lowerCamelCase      ,  __lowerCamelCase			)) or (precision < 0):
    raise ValueError("""Precision must be a nonnegative integer"""			)

  # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
  # accurate
  __A		:  int       				=		(
      4 * _subsum(__lowerCamelCase      ,  1      ,  __lowerCamelCase			)
      - 2 * _subsum(__lowerCamelCase      ,  4      ,  __lowerCamelCase			)
      - _subsum(__lowerCamelCase      ,  5      ,  __lowerCamelCase			)
      - _subsum(__lowerCamelCase      ,  6      ,  __lowerCamelCase			)
  )

  # return the first hex digit of the fractional part of the result
  return hex(int((sum_result % 1) * 16			)			)[2:]







def 							A_  (    __SCREAMING_SNAKE_CASE    :	List[str]      ,  __SCREAMING_SNAKE_CASE    :	Any      ,  __SCREAMING_SNAKE_CASE    :	Tuple			)					->							float:





  """simple docstring"""

  __A		:  List[str]       				=		0.0
  for sum_index in range(digit_pos_to_extract + precision			):
    __A		:  int       				=		8 * sum_index + denominator_addend
    if sum_index < digit_pos_to_extract:
      # if the exponential term is an integer and we mod it by the denominator
      # before dividing, only the integer part of the sum will change;
      # the fractional part will not
      __A		:  Tuple       				=		pow(
          16      ,  digit_pos_to_extract - 1 - sum_index      ,  __lowerCamelCase			)
    else:
      __A		:  List[Any]       				=		pow(16      ,  digit_pos_to_extract - 1 - sum_index			)
    total += exponential_term / denominator
  return total


if __name__ == "__main__":
     import doctest

     doctest.testmod()







import gc
import tempfile
import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionDualGuidedPipeline
from diffusers.utils.testing_utils import load_image, nightly, require_torch_gpu, torch_device


a					:				Optional[int]       =      False

@nightly
@require_torch_gpu
class   lowerCamelCase						(	unittest.TestCase  ):

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Optional[int]							=   VersatileDiffusionDualGuidedPipeline.from_pretrained('''shi-labs/versatile-diffusion'''       )
        # remove text_unet
        pipe.remove_unused_weights()
        pipe.to(a__       )
        pipe.set_progress_bar_config(disable=a__       )

        snake_case :			Union[str, Any]							=   load_image(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''       )

        snake_case :			str							=   torch.manual_seed(0       )
        snake_case :			Tuple							=   pipe(
            prompt='''first prompt'''						,    image=a__						,    text_to_image_strength=0.75						,    generator=a__						,    guidance_scale=7.5						,    num_inference_steps=2						,    output_type='''numpy'''						,    ).images

        with tempfile.TemporaryDirectory() as tmpdirname:
         pipe.save_pretrained(a__       )
         snake_case :			str							=   VersatileDiffusionDualGuidedPipeline.from_pretrained(a__       )

        pipe.to(a__       )
        pipe.set_progress_bar_config(disable=a__       )

        snake_case :			Optional[Any]							=   generator.manual_seed(0       )
        snake_case :			List[str]							=   pipe(
            prompt='''first prompt'''						,    image=a__						,    text_to_image_strength=0.75						,    generator=a__						,    guidance_scale=7.5						,    num_inference_steps=2						,    output_type='''numpy'''						,    ).images

        assert np.abs(image - new_image       ).sum() < 1e-5, "Models don't have the same forward pass"



       def 					UpperCAmelCase					(      self       ):






        '''simple docstring'''






        snake_case :			Tuple							=   VersatileDiffusionDualGuidedPipeline.from_pretrained('''shi-labs/versatile-diffusion'''       )
        pipe.remove_unused_weights()
        pipe.to(a__       )
        pipe.set_progress_bar_config(disable=a__       )

        snake_case :			int							=   '''cyberpunk 2077'''
        snake_case :			Dict							=   load_image(
            '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg'''       )
        snake_case :			Optional[int]							=   torch.manual_seed(0       )
        snake_case :			Union[str, Any]							=   pipe(
            prompt=a__						,    image=a__						,    text_to_image_strength=0.75						,    generator=a__						,    guidance_scale=7.5						,    num_inference_steps=50						,    output_type='''numpy'''						,    ).images

        snake_case :			str							=   image[0, 2_53:2_56, 2_53:2_56, -1]

        assert image.shape == (1, 5_12, 5_12, 3)
        snake_case :			int							=   np.array([0.0787, 0.0849, 0.0826, 0.0812, 0.0807, 0.0795, 0.0818, 0.0798, 0.0779]       )

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






