
"""simple docstring"""

import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    TextToVideoSDPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import is_xformers_available, load_numpy, skip_mps, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
@skip_mps
class      _UpperCAmelCase							(		SCREAMING_SNAKE_CASE_     ,			unittest.TestCase							):
      __SCREAMING_SNAKE_CASE   :							int							      =	TextToVideoSDPipeline
      __SCREAMING_SNAKE_CASE   :							Optional[int]							      =	TEXT_TO_IMAGE_PARAMS
      __SCREAMING_SNAKE_CASE   :							str							      =	TEXT_TO_IMAGE_BATCH_PARAMS
      # No `output_type`.
      __SCREAMING_SNAKE_CASE   :							Dict							      =	frozenset(
          [
              "num_inference_steps",
              "generator",
              "latents",
              "return_dict",
              "callback",
              "callback_steps",
          ]							)




      def     a_      (							self							)						->					Any:
          torch.manual_seed(0							)
          UpperCAmelCase									=					UNetaDConditionModel(
              block_out_channels=(3_2, 6_4, 6_4, 6_4)   ,       layers_per_block=2   ,       sample_size=3_2   ,       in_channels=4   ,       out_channels=4   ,       down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D')   ,       up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D')   ,       cross_attention_dim=3_2   ,       attention_head_dim=4   ,       )
          UpperCAmelCase									=					DDIMScheduler(
              beta_start=0.0_0_0_8_5   ,       beta_end=0.0_1_2   ,       beta_schedule='scaled_linear'   ,       clip_sample=lowercase_   ,       set_alpha_to_one=lowercase_   ,       )
          torch.manual_seed(0							)
          UpperCAmelCase									=					AutoencoderKL(
              block_out_channels=[3_2, 6_4]   ,       in_channels=3   ,       out_channels=3   ,       down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']   ,       up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']   ,       latent_channels=4   ,       sample_size=1_2_8   ,       )
          torch.manual_seed(0							)
          UpperCAmelCase									=					CLIPTextConfig(
              bos_token_id=0   ,       eos_token_id=2   ,       hidden_size=3_2   ,       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   ,       hidden_act='gelu'   ,       projection_dim=5_1_2   ,       )
          UpperCAmelCase									=					CLIPTextModel(lowercase_							)
          UpperCAmelCase									=					CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'							)

          UpperCAmelCase									=					{
              'unet': unet,
              'scheduler': scheduler,
              'vae': vae,
              'text_encoder': text_encoder,
              'tokenizer': tokenizer,
          }
          return components




      def     a_      (							self   ,       lowercase_   ,       lowercase_=0							)						->					List[Any]:
          if str(lowercase_							).startswith('mps'							):
              UpperCAmelCase									=					torch.manual_seed(lowercase_							)
          else:
              UpperCAmelCase									=					torch.Generator(device=lowercase_							).manual_seed(lowercase_							)
          UpperCAmelCase									=					{
              'prompt': 'A painting of a squirrel eating a burger',
              'generator': generator,
              'num_inference_steps': 2,
              'guidance_scale': 6.0,
              'output_type': 'pt',
          }
          return inputs




      def     a_      (							self							)						->					Dict:
          UpperCAmelCase									=					'cpu'  # ensure determinism for the device-dependent torch.Generator
          UpperCAmelCase									=					self.get_dummy_components()
          UpperCAmelCase									=					TextToVideoSDPipeline(**lowercase_							)
          UpperCAmelCase									=					sd_pipe.to(lowercase_							)
          sd_pipe.set_progress_bar_config(disable=lowercase_							)

          UpperCAmelCase									=					self.get_dummy_inputs(lowercase_							)
          UpperCAmelCase									=					'np'
          UpperCAmelCase									=					sd_pipe(**lowercase_							).frames
          UpperCAmelCase									=					frames[0][-3:, -3:, -1]

          assert frames[0].shape == (6_4, 6_4, 3)
          UpperCAmelCase									=					np.array([1_5_8.0, 1_6_0.0, 1_5_3.0, 1_2_5.0, 1_0_0.0, 1_2_1.0, 1_1_1.0, 9_3.0, 1_1_3.0]							)

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




      def     a_      (							self							)						->					int:
          self._test_attention_slicing_forward_pass(test_mean_pixel_difference=lowercase_   ,       expected_max_diff=3E-3							)




      @unittest.skipIf(
          torch_device != 'cuda' or not is_xformers_available()   ,       reason='XFormers attention is only available with CUDA and `xformers` installed'   ,       )
      def     a_      (							self							)						->					Optional[int]:
          self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowercase_   ,       expected_max_diff=1E-2							)




      @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'							)
      def     a_      (							self							)						->					List[Any]:
          pass




      @unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'							)
      def     a_      (							self							)						->					Optional[int]:
          pass




      @unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'							)
      def     a_      (							self							)						->					str:
          pass




      def     a_      (							self							)						->					Tuple:
          return super().test_progress_bar()

@slow
@skip_mps
class      _UpperCAmelCase							(		unittest.TestCase							):




      def     a_      (							self							)						->					List[str]:
          UpperCAmelCase									=					load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video.npy'							)

          UpperCAmelCase									=					TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'							)
          UpperCAmelCase									=					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config							)
          UpperCAmelCase									=					pipe.to('cuda'							)

          UpperCAmelCase									=					'Spiderman is surfing'
          UpperCAmelCase									=					torch.Generator(device='cpu'							).manual_seed(0							)

          UpperCAmelCase									=					pipe(lowercase_   ,       generator=lowercase_   ,       num_inference_steps=2_5   ,       output_type='pt'							).frames
          UpperCAmelCase									=					video_frames.cpu().numpy()

          assert np.abs(expected_video - video							).mean() < 5E-2




      def     a_      (							self							)						->					Tuple:
          UpperCAmelCase									=					load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/text_to_video/video_2step.npy'							)

          UpperCAmelCase									=					TextToVideoSDPipeline.from_pretrained('damo-vilab/text-to-video-ms-1.7b'							)
          UpperCAmelCase									=					pipe.to('cuda'							)

          UpperCAmelCase									=					'Spiderman is surfing'
          UpperCAmelCase									=					torch.Generator(device='cpu'							).manual_seed(0							)

          UpperCAmelCase									=					pipe(lowercase_   ,       generator=lowercase_   ,       num_inference_steps=2   ,       output_type='pt'							).frames
          UpperCAmelCase									=					video_frames.cpu().numpy()

          assert np.abs(expected_video - video							).mean() < 5E-2





"""simple docstring"""

import argparse
import datetime




def     lowercase__						(					lowerCAmelCase				:					str ) ->      str:






    """simple docstring"""




    UpperCAmelCase									=					{
        '0': 'Sunday',
        '1': 'Monday',
        '2': 'Tuesday',
        '3': 'Wednesday',
        '4': 'Thursday',
        '5': 'Friday',
        '6': 'Saturday',
    }

    UpperCAmelCase									=					{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}

    # Validate
    if not 0 < len(lowerCAmelCase ) < 11:
        raise ValueError('Must be 10 characters long' )

    # Get month
    UpperCAmelCase									=					int(date_input[0] + date_input[1] )
    # Validate
    if not 0 < m < 13:
        raise ValueError('Month must be between 1 - 12' )

    UpperCAmelCase									=					date_input[2]
    # Validate
    if sep_a not in ["-", "/"]:
        raise ValueError('Date separator must be \'-\' or \'/\'' )

    # Get day
    UpperCAmelCase									=					int(date_input[3] + date_input[4] )
    # Validate
    if not 0 < d < 32:
        raise ValueError('Date must be between 1 - 31' )

    # Get second separator
    UpperCAmelCase									=					date_input[5]
    # Validate
    if sep_a not in ["-", "/"]:
        raise ValueError('Date separator must be \'-\' or \'/\'' )

    # Get year
    UpperCAmelCase									=					int(date_input[6] + date_input[7] + date_input[8] + date_input[9] )
    # Arbitrary year range
    if not 45 < y < 8_500:
        raise ValueError(
            'Year out of range. There has to be some sort of limit...right?' )

    # Get datetime obj for validation
    UpperCAmelCase									=					datetime.date(int(lowerCAmelCase ) ,				int(lowerCAmelCase ) ,				int(lowerCAmelCase ) )

    # Start math
    if m <= 2:
        UpperCAmelCase									=					y - 1
        UpperCAmelCase									=					m + 12
    # maths var
    UpperCAmelCase									=					int(str(lowerCAmelCase )[:2] )
    UpperCAmelCase									=					int(str(lowerCAmelCase )[2:] )
    UpperCAmelCase									=					int(2.6 * m - 5.39 )
    UpperCAmelCase									=					int(c / 4 )
    UpperCAmelCase									=					int(k / 4 )
    UpperCAmelCase									=					int(d + k )
    UpperCAmelCase									=					int(t + u + v + x )
    UpperCAmelCase									=					int(z - (2 * c) )
    UpperCAmelCase									=					round(w % 7 )
    # End math

    # Validate math
    if f != convert_datetime_days[dt_ck.weekday()]:
        raise AssertionError('The date was evaluated incorrectly. Contact developer.' )

    # Response
    UpperCAmelCase									=					F"Your date {date_input}, is a {days[str(lowerCAmelCase )]}!"
    return response


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   SCREAMING_SNAKE_CASE_    					=						argparse.ArgumentParser(
       description=(
           '''Find out what day of the week nearly any date is or was. Enter '''
           '''date as a string in the mm-dd-yyyy or mm/dd/yyyy format'''
       )
   )
   parser.add_argument(
       '''date_input''', type=str, help='''Date as a string (mm-dd-yyyy or mm/dd/yyyy)'''
   )
   SCREAMING_SNAKE_CASE_    					=						parser.parse_args()
   zeller(args.date_input)



