





'''simple docstring'''







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        __a   (unittest.TestCase  ):

							def      UpperCAmelCase__						(				self				:  Optional[int] )       ->							Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_      :   Optional[Any]      =	'''runwayml/stable-diffusion-v1-5'''
													UpperCAmelCase_      :   Any      =	TextToVideoZeroPipeline.from_pretrained(__magic_name__							,  torch_dtype=torch.floataa ).to('''cuda''' )
													UpperCAmelCase_      :   Any      =	DDIMScheduler.from_config(pipe.scheduler.config )
													UpperCAmelCase_      :   Optional[Any]      =	torch.Generator(device='''cuda''' ).manual_seed(0 )

													UpperCAmelCase_      :   Dict      =	'''A bear is playing a guitar on Times Square'''
													UpperCAmelCase_      :   List[Any]      =	pipe(prompt=__magic_name__							,  generator=__magic_name__ ).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(__magic_name__							,  __magic_name__ )






'''simple docstring'''
from __future__ import annotations

import math
import random







def 				__UpperCamelCase (					__UpperCAmelCase  :					int ,   __UpperCAmelCase  :					int ,   __UpperCAmelCase  :					int			)							->	list[int]:
  lowercase				:							Union[str, Any]									=   d * e - 1
  lowercase				:							List[str]									=   0
  lowercase				:							Tuple									=   0
  while p == 0:
    lowercase				:							Optional[Any]									=   random.randint(2 ,   n - 1			)
    lowercase				:							Dict									=   k
    while True:
      if t % 2 == 0:
        lowercase				:							List[Any]									=   t // 2
        lowercase				:							Union[str, Any]									=   (g**t) % n
        lowercase				:							Optional[Any]									=   math.gcd(x - 1 ,   __UpperCAmelCase			)
        if x > 1 and y > 1:
          lowercase				:							Dict									=   y
          lowercase				:							Any									=   n // y
          break  # find the correct factors
      else:
        break  # t is not divisible by 2, break and choose another g
  return sorted([p, q]			)


if __name__ == "__main__":
 import doctest

 doctest.testmod()