
"""simple docstring"""
import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()
@skip_mps
class 			UpperCamelCase      (							_snake_case      ,       unittest.TestCase  ):
     A__      =			VideoToVideoSDPipeline
     A__      =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"""video"""}  ) - {"""image""", """width""", """height"""}
     A__      =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""video"""}  ) - {"""image"""}
     A__      =			PipelineTesterMixin.required_optional_params - {"""latents"""}
     A__      =			False

     # No `output_type`.
     A__      =			frozenset(
         [
             """num_inference_steps""",
             """generator""",
             """latents""",
             """return_dict""",
             """callback""",
             """callback_steps""",
         ]  )
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       torch.manual_seed(0				)
       _SCREAMING_SNAKE_CASE   :				List[Any]         = UNetaDConditionModel(
           block_out_channels=(32, 64, 64, 64)  ,     layers_per_block=2  ,     sample_size=32  ,     in_channels=4  ,     out_channels=4  ,     down_block_types=("CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "DownBlock3D")  ,     up_block_types=("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D")  ,     cross_attention_dim=32  ,     attention_head_dim=4  ,     )
       _SCREAMING_SNAKE_CASE   :				Optional[int]         = DDIMScheduler(
           beta_start=0.00_085  ,     beta_end=0.012  ,     beta_schedule="scaled_linear"  ,     clip_sample=lowerCAmelCase__  ,     set_alpha_to_one=lowerCAmelCase__  ,     )
       torch.manual_seed(0				)
       _SCREAMING_SNAKE_CASE   :				Tuple         = AutoencoderKL(
           block_out_channels=[32, 64]  ,     in_channels=3  ,     out_channels=3  ,     down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]  ,     up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]  ,     latent_channels=4  ,     sample_size=128  ,     )
       torch.manual_seed(0				)
       _SCREAMING_SNAKE_CASE   :				List[str]         = CLIPTextConfig(
           bos_token_id=0  ,     eos_token_id=2  ,     hidden_size=32  ,     intermediate_size=37  ,     layer_norm_eps=1E-05  ,     num_attention_heads=4  ,     num_hidden_layers=5  ,     pad_token_id=1  ,     vocab_size=1000  ,     hidden_act="gelu"  ,     projection_dim=512  ,     )
       _SCREAMING_SNAKE_CASE   :				Optional[Any]         = CLIPTextModel(lowerCAmelCase__				)
       _SCREAMING_SNAKE_CASE   :				Optional[Any]         = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)

       _SCREAMING_SNAKE_CASE   :				Tuple         = {
           "unet": unet,
           "scheduler": scheduler,
           "vae": vae,
           "text_encoder": text_encoder,
           "tokenizer": tokenizer,
       }
       return components
     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__=0				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = floats_tensor((1, 3, 3, 32, 32)  ,     rng=random.Random(lowerCAmelCase__				)				).to(lowerCAmelCase__				)

       if str(lowerCAmelCase__				).startswith("mps"				):
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = torch.manual_seed(lowerCAmelCase__				)
       else:
         _SCREAMING_SNAKE_CASE   :				str         = torch.Generator(device=lowerCAmelCase__				).manual_seed(lowerCAmelCase__				)
       _SCREAMING_SNAKE_CASE   :				Tuple         = {
           "prompt": "A painting of a squirrel eating a burger",
           "video": video,
           "generator": generator,
           "num_inference_steps": 2,
           "guidance_scale": 6.0,
           "output_type": "pt",
       }
       return inputs
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Tuple         = "cpu"  # ensure determinism for the device-dependent torch.Generator
       _SCREAMING_SNAKE_CASE   :				Optional[Any]         = self.get_dummy_components()
       _SCREAMING_SNAKE_CASE   :				int         = VideoToVideoSDPipeline(**lowerCAmelCase__				)
       _SCREAMING_SNAKE_CASE   :				Optional[Any]         = sd_pipe.to(lowerCAmelCase__				)
       sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__				)

       _SCREAMING_SNAKE_CASE   :				Optional[int]         = self.get_dummy_inputs(lowerCAmelCase__				)
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = "np"
       _SCREAMING_SNAKE_CASE   :				Any         = sd_pipe(**lowerCAmelCase__				).frames
       _SCREAMING_SNAKE_CASE   :				List[Any]         = frames[0][-3:, -3:, -1]

       assert frames[0].shape == (32, 32, 3)
       _SCREAMING_SNAKE_CASE   :				Optional[int]         = np.array([106, 117, 113, 174, 137, 112, 148, 151, 131]				)

       assert np.abs(image_slice.flatten() - expected_slice				).max() < 1E-2
     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available()  ,     reason="XFormers attention is only available with CUDA and `xformers` installed"  ,     )
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCAmelCase__  ,     expected_max_diff=5E-3				)
     @unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       pass
     @unittest.skip(reason="Batching needs to be properly figured out first for this pipeline."				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       pass
     @unittest.skip(reason="`num_images_per_prompt` argument is not supported for this pipeline."				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       pass




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       return super().test_progress_bar()
@slow
@skip_mps
class 			UpperCamelCase      (							unittest.TestCase  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				str         = VideoToVideoSDPipeline.from_pretrained("cerspense/zeroscope_v2_XL"  ,     torch_dtype=torch.floataa				)
       pipe.enable_model_cpu_offload()

       # 10 frames
       _SCREAMING_SNAKE_CASE   :				List[str]         = torch.Generator(device="cpu"				).manual_seed(0				)
       _SCREAMING_SNAKE_CASE   :				List[Any]         = torch.randn((1, 10, 3, 1024, 576)  ,     generator=lowerCAmelCase__				)
       _SCREAMING_SNAKE_CASE   :				List[Any]         = video.to("cuda"				)

       _SCREAMING_SNAKE_CASE   :				Union[str, Any]         = "Spiderman is surfing"

       _SCREAMING_SNAKE_CASE   :				str         = pipe(lowerCAmelCase__  ,     video=lowerCAmelCase__  ,     generator=lowerCAmelCase__  ,     num_inference_steps=3  ,     output_type="pt"				).frames

       _SCREAMING_SNAKE_CASE   :				str         = np.array([-1.0_458_984, -1.1_279_297, -0.9_663_086, -0.91_503_906, -0.75_097_656]				)
       assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array				).sum() < 1E-2





"""simple docstring"""
import operator as op





def    _lowerCAmelCase    (     lowerCamelCase__							:							Tuple				)  ->    List[str]:
  _SCREAMING_SNAKE_CASE   :				Optional[int]							    = []
  _SCREAMING_SNAKE_CASE   :				str							    = lambda lowerCamelCase__,						lowerCamelCase__				: int(x / y				)  # noqa: E731 integer division operation
  _SCREAMING_SNAKE_CASE   :				Any							    = {
      "^": op.pow,
      "*": op.mul,
      "/": div,
      "+": op.add,
      "-": op.sub,
  }  # operators & their respective operation

  # print table header
  print("Symbol".center(8				),						"Action".center(1_2				),						"Stack",						sep=" | "				)
  print("-" * (3_0 + len(lowerCamelCase__				))				)

  for x in post_fix:
    if x.isdigit():  # if x in digit
      stack.append(lowerCamelCase__				)  # append x to stack
      # output in tabular format
      print(x.rjust(8				),						("push(" + x + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | "				)
    else:
      _SCREAMING_SNAKE_CASE   :				Dict							    = stack.pop()  # pop stack
      # output in tabular format
      print("".rjust(8				),						("pop(" + b + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | "				)

      _SCREAMING_SNAKE_CASE   :				Any							    = stack.pop()  # pop stack
      # output in tabular format
      print("".rjust(8				),						("pop(" + a + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | "				)

      stack.append(
          str(opr[x](int(lowerCamelCase__				),						int(lowerCamelCase__				)				)				)				)  # evaluate the 2 values popped from stack & push result to stack
      # output in tabular format
      print(
          x.rjust(8				),						("push(" + a + x + b + ")").ljust(1_2				),						",".join(lowerCamelCase__				),						sep=" | ",						)

  return int(stack[0]				)


if __name__ == "__main__":
      lowercase_       :						int     					=	input('''\n\nEnter a Postfix Equation (space separated) = ''').split(''' ''')
      print('''\n\tResult = ''', solve(Postfix))



