



import unittest

import torch

from diffusers import DDIMScheduler, TextToVideoZeroPipeline
from diffusers.utils import load_pt, require_torch_gpu, slow

from ..test_pipelines_common import assert_mean_pixel_difference







@slow
@require_torch_gpu
class       _snake_case				(     unittest.TestCase ):






   '''simple docstring'''






   def       A__    (    self:     str							)	->      Tuple:
       UpperCAmelCase_     :       int  		=					"""runwayml/stable-diffusion-v1-5"""
       UpperCAmelCase_     :       Tuple  		=					TextToVideoZeroPipeline.from_pretrained(lowerCamelCase_  ,torch_dtype=torch.floataa							).to("""cuda"""							)
       UpperCAmelCase_     :       Optional[Any]  		=					DDIMScheduler.from_config(pipe.scheduler.config							)
       UpperCAmelCase_     :       Dict  		=					torch.Generator(device="""cuda"""							).manual_seed(0							)

       UpperCAmelCase_     :       Optional[int]  		=					"""A bear is playing a guitar on Times Square"""
       UpperCAmelCase_     :       List[str]  		=					pipe(prompt=lowerCamelCase_  ,generator=lowerCamelCase_							).images

       UpperCAmelCase_     :       Any  		=					load_pt(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text-to-video/A bear is playing a guitar on Times Square.pt"""							)

       assert_mean_pixel_difference(lowerCamelCase_  ,lowerCamelCase_							)



"""simple docstring"""





def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int = 1000)      ->		str:
   '''simple docstring'''


   if (not isinstance(UpperCamelCase_,     UpperCamelCase_)) or (digit_position <= 0):
      raise ValueError("Digit position must be a positive integer")
   elif (not isinstance(UpperCamelCase_,     UpperCamelCase_)) 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
   __lowercase								=		(
       4 * _subsum(UpperCamelCase_,     1,     UpperCamelCase_)
       - 2 * _subsum(UpperCamelCase_,     4,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     5,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     6,     UpperCamelCase_)
   )

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




def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int,     UpperCamelCase_	:			int)      ->		float:
   '''simple docstring'''


   __lowercase								=		0.0
   for sum_index in range(digit_pos_to_extract + precision):
      __lowercase								=		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
         __lowercase								=		pow(
             16,     digit_pos_to_extract - 1 - sum_index,     UpperCamelCase_)
      else:
         __lowercase								=		pow(16,     digit_pos_to_extract - 1 - sum_index)
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
   import doctest

   doctest.testmod()




