
def     _a					(						lowerCamelCase,	lowerCamelCase,	lowerCamelCase,	lowerCamelCase							):
 if height >= 1:
  move_tower(height - 1,	__UpperCAmelCase,	__UpperCAmelCase,	__UpperCAmelCase							)
  move_disk(__UpperCAmelCase,	__UpperCAmelCase							)
  move_tower(height - 1,	__UpperCAmelCase,	__UpperCAmelCase,	__UpperCAmelCase							)





def     _a					(						lowerCamelCase,	lowerCamelCase							):
 print("""moving disk from""",	__UpperCAmelCase,	"""to""",	__UpperCAmelCase							)





def     _a					(						):
 lowerCamelCase		:	str							=      int(input("""Height of hanoi: """							).strip()							)
 move_tower(__UpperCAmelCase,	"""A""",	"""B""",	"""C"""							)


if __name__ == "__main__":
      main()











import os
from glob import glob

import imageio
import torch
import torchvision
import wandb
from img_processing import custom_to_pil, loop_post_process, preprocess, preprocess_vqgan
from loaders import load_vqgan
from PIL import Image
from torch import nn

from transformers import CLIPModel, CLIPTokenizerFast
from utils import get_device, get_timestamp, show_pil






class     lowercase__       :

   '''simple docstring'''


   def __init__(    self,		__magic_name__ = "cpu",		__magic_name__ = "openai/clip-vit-large-patch14"							) ->      None:






       """simple docstring"""
       UpperCamelCase__							:				List[str]          =      device
       UpperCamelCase__							:				Union[str, Any]          =      CLIPTokenizerFast.from_pretrained(__magic_name__							)
       UpperCamelCase__							:				Tuple          =      [0.4814_5466, 0.457_8275, 0.4082_1073]
       UpperCamelCase__							:				Union[str, Any]          =      [0.2686_2954, 0.2613_0258, 0.2757_7711]
       UpperCamelCase__							:				Dict          =      torchvision.transforms.Normalize(self.image_mean,		self.image_std							)
       UpperCamelCase__							:				List[str]          =      torchvision.transforms.Resize(224							)
       UpperCamelCase__							:				Union[str, Any]          =      torchvision.transforms.CenterCrop(224							)




   def       UpperCamelCase__  (    self,		__magic_name__							) ->      List[Any]:






       """simple docstring"""
       UpperCamelCase__							:				Optional[Any]          =      self.resize(__magic_name__							)
       UpperCamelCase__							:				Dict          =      self.center_crop(__magic_name__							)
       UpperCamelCase__							:				List[str]          =      self.normalize(__magic_name__							)
       return images




   def __call__(    self,		__magic_name__=None,		__magic_name__=None,		**__magic_name__							) ->      Union[str, Any]:






       """simple docstring"""
       UpperCamelCase__							:				Optional[Any]          =      self.tokenizer(text=__magic_name__,		**__magic_name__							)
       UpperCamelCase__							:				List[Any]          =      self.preprocess_img(__magic_name__							)
       UpperCamelCase__							:				Optional[Any]          =      {key: value.to(self.device							) for (key, value) in encoding.items()}
       return encoding






class     lowercase__       (	nn.Module				):

   '''simple docstring'''


   def __init__(    self,		__magic_name__=10,		__magic_name__=0.01,		__magic_name__=None,		__magic_name__=None,		__magic_name__=None,		__magic_name__=None,		__magic_name__=None,		__magic_name__=None,		__magic_name__=False,		__magic_name__=True,		__magic_name__="image",		__magic_name__=True,		__magic_name__=False,		__magic_name__=False,		__magic_name__=False,		) ->      None:






       """simple docstring"""
       super().__init__()
       UpperCamelCase__							:				Dict          =      None
       UpperCamelCase__							:				Tuple          =      device if device else get_device()
       if vqgan:
           UpperCamelCase__							:				Union[str, Any]          =      vqgan
       else:
           UpperCamelCase__							:				Any          =      load_vqgan(self.device,		conf_path=__magic_name__,		ckpt_path=__magic_name__							)
       self.vqgan.eval()
       if clip:
           UpperCamelCase__							:				Optional[Any]          =      clip
       else:
           UpperCamelCase__							:				Any          =      CLIPModel.from_pretrained('''openai/clip-vit-base-patch32'''							)
       self.clip.to(self.device							)
       UpperCamelCase__							:				str          =      ProcessorGradientFlow(device=self.device							)

       UpperCamelCase__							:				Union[str, Any]          =      iterations
       UpperCamelCase__							:				Tuple          =      lr
       UpperCamelCase__							:				Optional[int]          =      log
       UpperCamelCase__							:				List[Any]          =      make_grid
       UpperCamelCase__							:				Optional[Any]          =      return_val
       UpperCamelCase__							:				str          =      quantize
       UpperCamelCase__							:				int          =      self.vqgan.decoder.z_shape




   def       UpperCamelCase__  (    self,		__magic_name__=None,		__magic_name__=None,		__magic_name__=5,		__magic_name__=True							) ->      Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:				Optional[int]          =      []
       if output_path is None:
           UpperCamelCase__							:				List[str]          =      '''./animation.gif'''
       if input_path is None:
           UpperCamelCase__							:				Union[str, Any]          =      self.save_path
       UpperCamelCase__							:				Tuple          =      sorted(glob(input_path + '''/*'''							)							)
       if not len(__magic_name__							):
           raise ValueError(
               '''No images found in save path, aborting (did you pass save_intermediate=True to the generate'''
               ''' function?)'''							)
       if len(__magic_name__							) == 1:
           print('''Only one image found in save path, (did you pass save_intermediate=True to the generate function?)'''							)
       UpperCamelCase__							:				Dict          =      total_duration / len(__magic_name__							)
       UpperCamelCase__							:				List[Any]          =      [frame_duration] * len(__magic_name__							)
       if extend_frames:
           UpperCamelCase__							:				List[Any]          =      1.5
           UpperCamelCase__							:				Any          =      3
       for file_name in paths:
           if file_name.endswith('''.png'''							):
               images.append(imageio.imread(__magic_name__							)							)
       imageio.mimsave(__magic_name__,		__magic_name__,		duration=__magic_name__							)
       print(f"gif saved to {output_path}"							)




   def       UpperCamelCase__  (    self,		__magic_name__=None,		__magic_name__=None							) ->      Any:






       """simple docstring"""
       if not (path or img):
           raise ValueError('''Input either path or tensor'''							)
       if img is not None:
           raise NotImplementedError
       UpperCamelCase__							:				List[Any]          =      preprocess(Image.open(__magic_name__							),		target_image_size=256							).to(self.device							)
       UpperCamelCase__							:				str          =      preprocess_vqgan(__magic_name__							)
       UpperCamelCase__   ,*UpperCamelCase__							:				Union[str, Any]          =      self.vqgan.encode(__magic_name__							)
       return z




   def       UpperCamelCase__  (    self,		__magic_name__							) ->      Any:






       """simple docstring"""
       UpperCamelCase__							:				Optional[Any]          =      self.latent.detach().requires_grad_()
       UpperCamelCase__							:				Any          =      base_latent + transform_vector
       if self.quantize:
           UpperCamelCase__   ,*UpperCamelCase__							:				int          =      self.vqgan.quantize(__magic_name__							)
       else:
           UpperCamelCase__							:				Optional[int]          =      trans_latent
       return self.vqgan.decode(__magic_name__							)




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__,		__magic_name__=None							) ->      Tuple:






       """simple docstring"""
       UpperCamelCase__							:				Optional[int]          =      self.clip_preprocessor(text=__magic_name__,		images=__magic_name__,		return_tensors='''pt''',		padding=__magic_name__							)
       UpperCamelCase__							:				Optional[int]          =      self.clip(**__magic_name__							)
       UpperCamelCase__							:				Tuple          =      clip_outputs.logits_per_image
       if weights is not None:
           UpperCamelCase__							:				List[Any]          =      similarity_logits * weights
       return similarity_logits.sum()




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__,		__magic_name__							) ->      Any:






       """simple docstring"""
       UpperCamelCase__							:				List[str]          =      self._get_clip_similarity(pos_prompts['''prompts'''],		__magic_name__,		weights=(1 / pos_prompts['''weights'''])							)
       if neg_prompts:
           UpperCamelCase__							:				Tuple          =      self._get_clip_similarity(neg_prompts['''prompts'''],		__magic_name__,		weights=neg_prompts['''weights''']							)
       else:
           UpperCamelCase__							:				Optional[int]          =      torch.tensor([1],		device=self.device							)
       UpperCamelCase__							:				Tuple          =      -torch.log(__magic_name__							) + torch.log(__magic_name__							)
       return loss




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__,		__magic_name__							) ->      Optional[Any]:






       """simple docstring"""
       UpperCamelCase__							:				List[str]          =      torch.randn_like(self.latent,		requires_grad=__magic_name__,		device=self.device							)
       UpperCamelCase__							:				Optional[int]          =      torch.optim.Adam([vector],		lr=self.lr							)

       for i in range(self.iterations							):
           optim.zero_grad()
           UpperCamelCase__							:				Tuple          =      self._add_vector(__magic_name__							)
           UpperCamelCase__							:				Any          =      loop_post_process(__magic_name__							)
           UpperCamelCase__							:				Union[str, Any]          =      self._get_CLIP_loss(__magic_name__,		__magic_name__,		__magic_name__							)
           print('''CLIP loss''',		__magic_name__							)
           if self.log:
               wandb.log({'''CLIP Loss''': clip_loss}							)
           clip_loss.backward(retain_graph=__magic_name__							)
           optim.step()
           if self.return_val == "image":
               yield custom_to_pil(transformed_img[0]							)
           else:
               yield vector




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__,		__magic_name__							) ->      List[str]:






       """simple docstring"""
       wandb.init(reinit=__magic_name__,		project='''face-editor'''							)
       wandb.config.update({'''Positive Prompts''': positive_prompts}							)
       wandb.config.update({'''Negative Prompts''': negative_prompts}							)
       wandb.config.update({'''lr''': self.lr, '''iterations''': self.iterations}							)
       if image_path:
           UpperCamelCase__							:				List[str]          =      Image.open(__magic_name__							)
           UpperCamelCase__							:				List[Any]          =      image.resize((256, 256)							)
           wandb.log('''Original Image''',		wandb.Image(__magic_name__							)							)




   def       UpperCamelCase__  (    self,		__magic_name__							) ->      Optional[int]:






       """simple docstring"""
       if not prompts:
           return []
       UpperCamelCase__							:				int          =      []
       UpperCamelCase__							:				str          =      []
       if isinstance(__magic_name__,		__magic_name__							):
           UpperCamelCase__							:				Optional[Any]          =      [prompt.strip() for prompt in prompts.split('''|'''							)]
       for prompt in prompts:
           if isinstance(__magic_name__,		(tuple, list)							):
               UpperCamelCase__							:				Optional[int]          =      prompt[0]
               UpperCamelCase__							:				Dict          =      float(prompt[1]							)
           elif ":" in prompt:
               UpperCamelCase__   ,UpperCamelCase__							:				Optional[int]          =      prompt.split(''':'''							)
               UpperCamelCase__							:				List[Any]          =      float(__magic_name__							)
           else:
               UpperCamelCase__							:				List[str]          =      prompt
               UpperCamelCase__							:				Any          =      1.0
           processed_prompts.append(__magic_name__							)
           weights.append(__magic_name__							)
       return {
           "prompts": processed_prompts,
           "weights": torch.tensor(__magic_name__,		device=self.device							),
       }




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__=None,		__magic_name__=None,		__magic_name__=True,		__magic_name__=False,		__magic_name__=True,		__magic_name__=True,		__magic_name__=None,		) ->      str:






       """simple docstring"""
       if image_path:
           UpperCamelCase__							:				Union[str, Any]          =      self._get_latent(__magic_name__							)
       else:
           UpperCamelCase__							:				Dict          =      torch.randn(self.latent_dim,		device=self.device							)
       if self.log:
           self._init_logging(__magic_name__,		__magic_name__,		__magic_name__							)

       assert pos_prompts, "You must provide at least one positive prompt."
       UpperCamelCase__							:				Optional[Any]          =      self.process_prompts(__magic_name__							)
       UpperCamelCase__							:				Union[str, Any]          =      self.process_prompts(__magic_name__							)
       if save_final and save_path is None:
           UpperCamelCase__							:				str          =      os.path.join('''./outputs/''',		'''_'''.join(pos_prompts['''prompts''']							)							)
       if not os.path.exists(__magic_name__							):
           os.makedirs(__magic_name__							)
       else:
           UpperCamelCase__							:				int          =      save_path + '''_''' + get_timestamp()
           os.makedirs(__magic_name__							)
       UpperCamelCase__							:				Optional[Any]          =      save_path

       UpperCamelCase__							:				str          =      self.vqgan.decode(self.latent							)[0]
       if show_intermediate:
           print('''Original Image'''							)
           show_pil(custom_to_pil(__magic_name__							)							)

       UpperCamelCase__							:				Optional[Any]          =      loop_post_process(__magic_name__							)
       for iter, transformed_img in enumerate(self._optimize_CLIP(__magic_name__,		__magic_name__,		__magic_name__							)							):
           if show_intermediate:
               show_pil(__magic_name__							)
           if save_intermediate:
               transformed_img.save(os.path.join(self.save_path,		f"iter_{iter:03d}.png"							)							)
           if self.log:
               wandb.log({'''Image''': wandb.Image(__magic_name__							)}							)
       if show_final:
           show_pil(__magic_name__							)
       if save_final:
           transformed_img.save(os.path.join(self.save_path,		f"iter_{iter:03d}_final.png"							)							)

