






"""simple docstring"""




from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
import torch
from transformers import CLIPImageProcessor, CLIPVisionModel

from ...models import PriorTransformer
from ...pipelines import DiffusionPipeline
from ...schedulers import HeunDiscreteScheduler
from ...utils import (
    BaseOutput,
    is_accelerate_available,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .renderer import ShapERenderer


UpperCamelCase							       =    logging.get_logger(__name__)  # pylint: disable=invalid-name

UpperCamelCase							       =    '\n    Examples:\n        ```py\n        >>> from PIL import Image\n        >>> import torch\n        >>> from diffusers import DiffusionPipeline\n        >>> from diffusers.utils import export_to_gif, load_image\n\n        >>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")\n\n        >>> repo = "openai/shap-e-img2img"\n        >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)\n        >>> pipe = pipe.to(device)\n\n        >>> guidance_scale = 3.0\n        >>> image_url = "https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png"\n        >>> image = load_image(image_url).convert("RGB")\n\n        >>> images = pipe(\n        ...     image,\n        ...     guidance_scale=guidance_scale,\n        ...     num_inference_steps=64,\n        ...     frame_size=256,\n        ... ).images\n\n        >>> gif_path = export_to_gif(images[0], "corgi_3d.gif")\n        ```\n'




@dataclass
class    lowercase_    (snake_case__     ):
      A__	:		Union[PIL.Image.Image, np.ndarray]







class    lowercase_    (snake_case__     ):






      def __init__(    self     ,     a_     ,     a_     ,     a_     ,     a_     ,     a_     ,     )	->int:







        '''simple docstring'''


        super().__init__()

        self.register_modules(
            prior=UpperCAmelCase_     ,     image_encoder=UpperCAmelCase_     ,     image_processor=UpperCAmelCase_     ,     scheduler=UpperCAmelCase_     ,     renderer=UpperCAmelCase_     ,     )






      def 			lowerCamelCase__    (    self     ,     a_     ,     a_     ,     a_     ,     a_     ,     a_     ,     a_	)	->Union[str, Any]:







        '''simple docstring'''


        if latents is None:
          _a							=	randn_tensor(UpperCAmelCase_     ,     generator=UpperCAmelCase_     ,     device=UpperCAmelCase_     ,     dtype=UpperCAmelCase_	)
        else:
          if latents.shape != shape:
            raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {shape}'''	)
          _a							=	latents.to(UpperCAmelCase_	)

        _a							=	latents * scheduler.init_noise_sigma
        return latents






      def 			lowerCamelCase__    (    self     ,     a_=0	)	->Optional[int]:







        '''simple docstring'''


        if is_accelerate_available():
          from accelerate import cpu_offload
        else:
          raise ImportError("Please install accelerate via `pip install accelerate`"	)

        _a							=	torch.device(f'''cuda:{gpu_id}'''	)

        _a							=	[self.image_encoder, self.prior]
        for cpu_offloaded_model in models:
          if cpu_offloaded_model is not None:
            cpu_offload(UpperCAmelCase_     ,     UpperCAmelCase_	)






      @property
      def 			lowerCamelCase__    (    self	)	->Optional[int]:







        '''simple docstring'''


        if self.device != torch.device("meta"	) or not hasattr(self.image_encoder     ,     "_hf_hook"	):
          return self.device
        for module in self.image_encoder.modules():
          if (
              hasattr(UpperCAmelCase_     ,     "_hf_hook"	)
              and hasattr(module._hf_hook     ,     "execution_device"	)
              and module._hf_hook.execution_device is not None
          ):
            return torch.device(module._hf_hook.execution_device	)
        return self.device






      def 			lowerCamelCase__    (    self     ,     a_     ,     a_     ,     a_     ,     a_     ,     )	->Optional[int]:







        '''simple docstring'''


        if isinstance(UpperCAmelCase_     ,     UpperCAmelCase_	) and isinstance(image[0]     ,     torch.Tensor	):
          _a							=	torch.cat(UpperCAmelCase_     ,     axis=0	) if image[0].ndim == 4 else torch.stack(UpperCAmelCase_     ,     axis=0	)

        if not isinstance(UpperCAmelCase_     ,     torch.Tensor	):
          _a							=	self.image_processor(UpperCAmelCase_     ,     return_tensors="pt"	).pixel_values[0].unsqueeze(0	)

        _a							=	image.to(dtype=self.image_encoder.dtype     ,     device=UpperCAmelCase_	)

        _a							=	self.image_encoder(UpperCAmelCase_	)["last_hidden_state"]
        _a							=	image_embeds[:, 1:, :].contiguous()  # batch_size, dim, 256

        _a							=	image_embeds.repeat_interleave(UpperCAmelCase_     ,     dim=0	)

        if do_classifier_free_guidance:
          _a							=	torch.zeros_like(UpperCAmelCase_	)

          # For classifier free guidance, we need to do two forward passes.
          # Here we concatenate the unconditional and text embeddings into a single batch
          # to avoid doing two forward passes
          _a							=	torch.cat([negative_image_embeds, image_embeds]	)

        return image_embeds






      @torch.no_grad()
      @replace_example_docstring(UpperCAmelCase_	)
      def __call__(    self     ,     a_     ,     a_ = 1     ,     a_ = 2_5     ,     a_ = None     ,     a_ = None     ,     a_ = 4.0     ,     a_ = 6_4     ,     a_ = "pil"     ,     a_ = True     ,     )	->Any:







        '''simple docstring'''


        if isinstance(UpperCAmelCase_     ,     PIL.Image.Image	):
          _a							=	1
        elif isinstance(UpperCAmelCase_     ,     torch.Tensor	):
          _a							=	image.shape[0]
        elif isinstance(UpperCAmelCase_     ,     UpperCAmelCase_	) and isinstance(image[0]     ,     (torch.Tensor, PIL.Image.Image)	):
          _a							=	len(UpperCAmelCase_	)
        else:
          raise ValueError(
              f'''`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(UpperCAmelCase_	)}'''	)

        _a							=	self._execution_device

        _a							=	batch_size * num_images_per_prompt

        _a							=	guidance_scale > 1.0
        _a							=	self._encode_image(UpperCAmelCase_     ,     UpperCAmelCase_     ,     UpperCAmelCase_     ,     UpperCAmelCase_	)

        # prior

        self.scheduler.set_timesteps(UpperCAmelCase_     ,     device=UpperCAmelCase_	)
        _a							=	self.scheduler.timesteps

        _a							=	self.prior.config.num_embeddings
        _a							=	self.prior.config.embedding_dim

        _a							=	self.prepare_latents(
            (batch_size, num_embeddings * embedding_dim)     ,     image_embeds.dtype     ,     UpperCAmelCase_     ,     UpperCAmelCase_     ,     UpperCAmelCase_     ,     self.scheduler     ,     )

        # YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim
        _a							=	latents.reshape(latents.shape[0]     ,     UpperCAmelCase_     ,     UpperCAmelCase_	)

        for i, t in enumerate(self.progress_bar(UpperCAmelCase_	)	):
          # expand the latents if we are doing classifier free guidance
          _a							=	torch.cat([latents] * 2	) if do_classifier_free_guidance else latents
          _a							=	self.scheduler.scale_model_input(UpperCAmelCase_     ,     UpperCAmelCase_	)

          _a							=	self.prior(
              UpperCAmelCase_     ,     timestep=UpperCAmelCase_     ,     proj_embedding=UpperCAmelCase_     ,     ).predicted_image_embedding

          # remove the variance
          _a			,	_a							=	noise_pred.split(
              scaled_model_input.shape[2]     ,     dim=2	)  # batch_size, num_embeddings, embedding_dim

          if do_classifier_free_guidance is not None:
            _a			,	_a							=	noise_pred.chunk(2	)
            _a							=	noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)

          _a							=	self.scheduler.step(
              UpperCAmelCase_     ,     timestep=UpperCAmelCase_     ,     sample=UpperCAmelCase_     ,     ).prev_sample

        if output_type == "latent":
          return ShapEPipelineOutput(images=UpperCAmelCase_	)

        _a							=	[]
        for i, latent in enumerate(UpperCAmelCase_	):
          print()
          _a							=	self.renderer.decode(
              latent[None, :]     ,     UpperCAmelCase_     ,     size=UpperCAmelCase_     ,     ray_batch_size=4_0_9_6     ,     n_coarse_samples=6_4     ,     n_fine_samples=1_2_8     ,     )

          images.append(UpperCAmelCase_	)

        _a							=	torch.stack(UpperCAmelCase_	)

        if output_type not in ["np", "pil"]:
          raise ValueError(f'''Only the output types `pil` and `np` are supported not output_type={output_type}'''	)

        _a							=	images.cpu().numpy()

        if output_type == "pil":
          _a							=	[self.numpy_to_pil(UpperCAmelCase_	) for image in images]

        # Offload last model to CPU
        if hasattr(self     ,     "final_offload_hook"	) and self.final_offload_hook is not None:
          self.final_offload_hook.offload()

        if not return_dict:
          return (images,)

        return ShapEPipelineOutput(images=UpperCAmelCase_	)







"""simple docstring"""




import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


UpperCamelCase							       =    logging.get_logger(__name__)

UpperCamelCase							       =    OrderedDict(
    [
        ("""align""", """EfficientNetImageProcessor"""),
        ("""beit""", """BeitImageProcessor"""),
        ("""bit""", """BitImageProcessor"""),
        ("""blip""", """BlipImageProcessor"""),
        ("""blip-2""", """BlipImageProcessor"""),
        ("""bridgetower""", """BridgeTowerImageProcessor"""),
        ("""chinese_clip""", """ChineseCLIPImageProcessor"""),
        ("""clip""", """CLIPImageProcessor"""),
        ("""clipseg""", """ViTImageProcessor"""),
        ("""conditional_detr""", """ConditionalDetrImageProcessor"""),
        ("""convnext""", """ConvNextImageProcessor"""),
        ("""convnextv2""", """ConvNextImageProcessor"""),
        ("""cvt""", """ConvNextImageProcessor"""),
        ("""data2vec-vision""", """BeitImageProcessor"""),
        ("""deformable_detr""", """DeformableDetrImageProcessor"""),
        ("""deit""", """DeiTImageProcessor"""),
        ("""deta""", """DetaImageProcessor"""),
        ("""detr""", """DetrImageProcessor"""),
        ("""dinat""", """ViTImageProcessor"""),
        ("""donut-swin""", """DonutImageProcessor"""),
        ("""dpt""", """DPTImageProcessor"""),
        ("""efficientformer""", """EfficientFormerImageProcessor"""),
        ("""efficientnet""", """EfficientNetImageProcessor"""),
        ("""flava""", """FlavaImageProcessor"""),
        ("""focalnet""", """BitImageProcessor"""),
        ("""git""", """CLIPImageProcessor"""),
        ("""glpn""", """GLPNImageProcessor"""),
        ("""groupvit""", """CLIPImageProcessor"""),
        ("""imagegpt""", """ImageGPTImageProcessor"""),
        ("""instructblip""", """BlipImageProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2ImageProcessor"""),
        ("""layoutlmv3""", """LayoutLMv3ImageProcessor"""),
        ("""levit""", """LevitImageProcessor"""),
        ("""mask2former""", """Mask2FormerImageProcessor"""),
        ("""maskformer""", """MaskFormerImageProcessor"""),
        ("""mgp-str""", """ViTImageProcessor"""),
        ("""mobilenet_v1""", """MobileNetV1ImageProcessor"""),
        ("""mobilenet_v2""", """MobileNetV2ImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevitv2""", """MobileViTImageProcessor"""),
        ("""nat""", """ViTImageProcessor"""),
        ("""oneformer""", """OneFormerImageProcessor"""),
        ("""owlvit""", """OwlViTImageProcessor"""),
        ("""perceiver""", """PerceiverImageProcessor"""),
        ("""pix2struct""", """Pix2StructImageProcessor"""),
        ("""poolformer""", """PoolFormerImageProcessor"""),
        ("""regnet""", """ConvNextImageProcessor"""),
        ("""resnet""", """ConvNextImageProcessor"""),
        ("""sam""", """SamImageProcessor"""),
        ("""segformer""", """SegformerImageProcessor"""),
        ("""swiftformer""", """ViTImageProcessor"""),
        ("""swin""", """ViTImageProcessor"""),
        ("""swin2sr""", """Swin2SRImageProcessor"""),
        ("""swinv2""", """ViTImageProcessor"""),
        ("""table-transformer""", """DetrImageProcessor"""),
        ("""timesformer""", """VideoMAEImageProcessor"""),
        ("""tvlt""", """TvltImageProcessor"""),
        ("""upernet""", """SegformerImageProcessor"""),
        ("""van""", """ConvNextImageProcessor"""),
        ("""videomae""", """VideoMAEImageProcessor"""),
        ("""vilt""", """ViltImageProcessor"""),
        ("""vit""", """ViTImageProcessor"""),
        ("""vit_hybrid""", """ViTHybridImageProcessor"""),
        ("""vit_mae""", """ViTImageProcessor"""),
        ("""vit_msn""", """ViTImageProcessor"""),
        ("""xclip""", """CLIPImageProcessor"""),
        ("""yolos""", """YolosImageProcessor"""),
    ]
)

UpperCamelCase							       =    _LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)






def        lowerCAmelCase (      UpperCamelCase_:							str					)       ->							Union[str, Any]:







  '''simple docstring'''







  for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
    if class_name in extractors:
      _a							=	model_type_to_module_name(UpperCamelCase_					)

      _a							=	importlib.import_module(f'''.{module_name}'''     , "transformers.models"					)
      try:
        return getattr(UpperCamelCase_     , UpperCamelCase_					)
      except AttributeError:
        continue

  for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
    if getattr(UpperCamelCase_     , "__name__"     , UpperCamelCase_					) == class_name:
      return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
  _a							=	importlib.import_module("transformers"					)
  if hasattr(UpperCamelCase_     , UpperCamelCase_					):
    return getattr(UpperCamelCase_     , UpperCamelCase_					)

  return None






def        lowerCAmelCase (      UpperCamelCase_:							Union[str, os.PathLike]     , UpperCamelCase_:							Optional[Union[str, os.PathLike]] = None     , UpperCamelCase_:							bool = False     , UpperCamelCase_:							bool = False     , UpperCamelCase_:							Optional[Dict[str, str]] = None     , UpperCamelCase_:							Optional[Union[bool, str]] = None     , UpperCamelCase_:							Optional[str] = None     , UpperCamelCase_:							bool = False     , **UpperCamelCase_:							Dict     , )       ->							Optional[int]:







  '''simple docstring'''







  _a							=	get_file_from_repo(
      UpperCamelCase_     , UpperCamelCase_     , cache_dir=UpperCamelCase_     , force_download=UpperCamelCase_     , resume_download=UpperCamelCase_     , proxies=UpperCamelCase_     , use_auth_token=UpperCamelCase_     , revision=UpperCamelCase_     , local_files_only=UpperCamelCase_     , )
  if resolved_config_file is None:
    logger.info(
        "Could not locate the image processor configuration file, will try to use the model config instead."					)
    return {}

  with open(UpperCamelCase_     , encoding="utf-8"					) as reader:
    return json.load(UpperCamelCase_					)




class    lowercase_    :






      def __init__(    self	)	->List[Any]:







        '''simple docstring'''


        raise EnvironmentError(
            "AutoImageProcessor is designed to be instantiated "
            "using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method."	)






      @classmethod
      @replace_list_option_in_docstrings(a_	)
      def 			lowerCamelCase__    (    cls     ,     a_     ,     **a_	)	->Dict:







        '''simple docstring'''


        _a							=	kwargs.pop("config"     ,     a_	)
        _a							=	kwargs.pop("trust_remote_code"     ,     a_	)
        _a							=	True

        _a			,	_a							=	ImageProcessingMixin.get_image_processor_dict(a_     ,     **a_	)
        _a							=	config_dict.get("image_processor_type"     ,     a_	)
        _a							=	None
        if "AutoImageProcessor" in config_dict.get("auto_map"     ,     {}	):
          _a							=	config_dict["auto_map"]["AutoImageProcessor"]

        # If we still don't have the image processor class, check if we're loading from a previous feature extractor config
        # and if so, infer the image processor class from there.
        if image_processor_class is None and image_processor_auto_map is None:
          _a							=	config_dict.pop("feature_extractor_type"     ,     a_	)
          if feature_extractor_class is not None:
            logger.warning(
                "Could not find image processor class in the image processor config or the model config. Loading"
                " based on pattern matching with the model's feature extractor configuration."	)
            _a							=	feature_extractor_class.replace("FeatureExtractor"     ,     "ImageProcessor"	)
          if "AutoFeatureExtractor" in config_dict.get("auto_map"     ,     {}	):
            _a							=	config_dict["auto_map"]["AutoFeatureExtractor"]
            _a							=	feature_extractor_auto_map.replace("FeatureExtractor"     ,     "ImageProcessor"	)
            logger.warning(
                "Could not find image processor auto map in the image processor config or the model config."
                " Loading based on pattern matching with the model's feature extractor configuration."	)

        # If we don't find the image processor class in the image processor config, let's try the model config.
        if image_processor_class is None and image_processor_auto_map is None:
          if not isinstance(a_     ,     a_	):
            _a							=	AutoConfig.from_pretrained(a_     ,     **a_	)
          # It could be in `config.image_processor_type``
          _a							=	getattr(a_     ,     "image_processor_type"     ,     a_	)
          if hasattr(a_     ,     "auto_map"	) and "AutoImageProcessor" in config.auto_map:
            _a							=	config.auto_map["AutoImageProcessor"]

        if image_processor_class is not None:
          _a							=	image_processor_class_from_name(a_	)

        _a							=	image_processor_auto_map is not None
        _a							=	image_processor_class is not None or type(a_	) in IMAGE_PROCESSOR_MAPPING
        _a							=	resolve_trust_remote_code(
            a_     ,     a_     ,     a_     ,     a_	)

        if has_remote_code and trust_remote_code:
          _a							=	get_class_from_dynamic_module(
              a_     ,     a_     ,     **a_	)
          _a							=	kwargs.pop("code_revision"     ,     a_	)
          if os.path.isdir(a_	):
            image_processor_class.register_for_auto_class()
          return image_processor_class.from_dict(a_     ,     **a_	)
        elif image_processor_class is not None:
          return image_processor_class.from_dict(a_     ,     **a_	)
        # Last try: we use the IMAGE_PROCESSOR_MAPPING.
        elif type(a_	) in IMAGE_PROCESSOR_MAPPING:
          _a							=	IMAGE_PROCESSOR_MAPPING[type(a_	)]
          return image_processor_class.from_dict(a_     ,     **a_	)

        raise ValueError(
            f'''Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '''
            f'''`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '''
            f'''`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()	)}'''	)






      @staticmethod
      def 			lowerCamelCase__    (    a_     ,     a_	)	->Optional[int]:







        '''simple docstring'''


        IMAGE_PROCESSOR_MAPPING.register(a_     ,     a_	)


