

"""simple docstring"""





from typing import List, Optional, Union

import numpy as np
import PIL
import torch
from PIL import Image

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


__UpperCamelCase    : Optional[Any]				 =						logging.get_logger(__name__)  # pylint: disable=invalid-name

__UpperCamelCase    : Tuple				 =						'''\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyV22Img2ImgPipeline, KandinskyV22PriorPipeline\n        >>> from diffusers.utils import load_image\n        >>> import torch\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n        ...     "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16\n        ... )\n        >>> pipe_prior.to("cuda")\n\n        >>> prompt = "A red cartoon frog, 4k"\n        >>> image_emb, zero_image_emb = pipe_prior(prompt, return_dict=False)\n\n        >>> pipe = KandinskyV22Img2ImgPipeline.from_pretrained(\n        ...     "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16\n        ... )\n        >>> pipe.to("cuda")\n\n        >>> init_image = load_image(\n        ...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"\n        ...     "/kandinsky/frog.png"\n        ... )\n\n        >>> image = pipe(\n        ...     image=init_image,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ...     strength=0.2,\n        ... ).images\n\n        >>> image[0].save("red_frog.png")\n        ```\n'''

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_		,	A_=8					):
	lowerCAmelCase__      :		List[str]    							=      height // scale_factor**2
	if height % scale_factor**2 != 0:
		new_height += 1
	lowerCAmelCase__      :		Any    							=      width // scale_factor**2
	if width % scale_factor**2 != 0:
		new_width += 1
	return new_height * scale_factor, new_width * scale_factor

def     __SCREAMING_SNAKE_CASE    ( A_		,	A_=5_12		,	A_=5_12					):
	lowerCAmelCase__      :		int    							=      pil_image.resize((w, h)		,	resample=Image.BICUBIC		,	reducing_gap=1					)
	lowerCAmelCase__      :		str    							=      np.array(pil_image.convert('''RGB'''					)					)
	lowerCAmelCase__      :		str    							=      arr.astype(np.floataa					) / 1_27.5 - 1
	lowerCAmelCase__      :		Dict    							=      np.transpose(__UpperCAmelCase		,	[2, 0, 1]					)
	lowerCAmelCase__      :		Union[str, Any]    							=      torch.from_numpy(__UpperCAmelCase					).unsqueeze(0					)
	return image







class 							SCREAMING_SNAKE_CASE   (						SCREAMING_SNAKE_CASE_			):






					"""simple docstring"""



					def __init__(			self     :							List[str]  ,lowercase_     :							UNetaDConditionModel  ,lowercase_     :							DDPMScheduler  ,lowercase_     :							VQModel  ,):
						super().__init__()

						self.register_modules(
						    unet=__snake_case  ,scheduler=__snake_case  ,movq=__snake_case  ,)
						lowerCAmelCase__      :		Tuple    							=      2 ** (len(self.movq.config.block_out_channels						) - 1)







					def 			__lowerCAmelCase					(			self     :							str  ,lowercase_     :							List[Any]  ,lowercase_     :							str  ,lowercase_     :							Any						):
						# get the original timestep using init_timestep
						lowerCAmelCase__      :		str    							=      min(int(num_inference_steps * strength						)  ,__snake_case						)

						lowerCAmelCase__      :		Dict    							=      max(num_inference_steps - init_timestep  ,0						)
						lowerCAmelCase__      :		Tuple    							=      self.scheduler.timesteps[t_start:]

						return timesteps, num_inference_steps - t_start







					def 			__lowerCAmelCase					(			self     :							Dict  ,lowercase_     :							List[Any]  ,lowercase_     :							List[str]  ,lowercase_     :							Tuple  ,lowercase_     :							Union[str, Any]  ,lowercase_     :							Union[str, Any]  ,lowercase_     :							Optional[Any]  ,lowercase_     :							Optional[Any]=None						):
						if not isinstance(__snake_case  ,(torch.Tensor, PIL.Image.Image, list)						):
							raise ValueError(
							    F'`image` has to be of type `torch.Tensor`, `PIL.Image.Image` or list but is {type(__snake_case						)}'						)

						lowerCAmelCase__      :		Union[str, Any]    							=      image.to(device=__snake_case  ,dtype=__snake_case						)

						lowerCAmelCase__      :		List[str]    							=      batch_size * num_images_per_prompt

						if image.shape[1] == 4:
							lowerCAmelCase__      :		Dict    							=      image

						else:
							if isinstance(__snake_case  ,__snake_case						) and len(__snake_case						) != batch_size:
								raise ValueError(
								    F'You have passed a list of generators of length {len(__snake_case						)}, but requested an effective batch'
								    F' size of {batch_size}. Make sure the batch size matches the length of the generators.'						)

							elif isinstance(__snake_case  ,__snake_case						):
								lowerCAmelCase__      :		str    							=      [
								    self.movq.encode(image[i : i + 1]						).latent_dist.sample(generator[i]						) for i in range(__snake_case						)
								]
								lowerCAmelCase__      :		List[Any]    							=      torch.cat(__snake_case  ,dim=0						)
							else:
								lowerCAmelCase__      :		Any    							=      self.movq.encode(__snake_case						).latent_dist.sample(__snake_case						)

							lowerCAmelCase__      :		str    							=      self.movq.config.scaling_factor * init_latents

						lowerCAmelCase__      :		Optional[Any]    							=      torch.cat([init_latents]  ,dim=0						)

						lowerCAmelCase__      :		Optional[Any]    							=      init_latents.shape
						lowerCAmelCase__      :		Dict    							=      randn_tensor(__snake_case  ,generator=__snake_case  ,device=__snake_case  ,dtype=__snake_case						)

						# get latents
						lowerCAmelCase__      :		Optional[Any]    							=      self.scheduler.add_noise(__snake_case  ,__snake_case  ,__snake_case						)

						lowerCAmelCase__      :		Optional[Any]    							=      init_latents

						return latents







					def 			__lowerCAmelCase					(			self     :							List[str]  ,lowercase_     :							Tuple=0						):
						if is_accelerate_available():
							from accelerate import cpu_offload
						else:
							raise ImportError('''Please install accelerate via `pip install accelerate`'''						)

						lowerCAmelCase__      :		str    							=      torch.device(F'cuda:{gpu_id}'						)

						lowerCAmelCase__      :		List[str]    							=      [
						    self.unet,
						    self.movq,
						]
						for cpu_offloaded_model in models:
							if cpu_offloaded_model is not None:
								cpu_offload(__snake_case  ,__snake_case						)







					def 			__lowerCAmelCase					(			self     :							List[str]  ,lowercase_     :							Optional[Any]=0						):
						if is_accelerate_available() and is_accelerate_version('''>='''  ,'''0.17.0.dev0'''						):
							from accelerate import cpu_offload_with_hook
						else:
							raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''						)

						lowerCAmelCase__      :		Any    							=      torch.device(F'cuda:{gpu_id}'						)

						if self.device.type != "cpu":
							self.to('''cpu'''  ,silence_dtype_warnings=__snake_case						)
							torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

						lowerCAmelCase__      :		Tuple    							=      None
						for cpu_offloaded_model in [self.unet, self.movq]:
							lowerCAmelCase__      :		Any    							=      cpu_offload_with_hook(__snake_case  ,__snake_case  ,prev_module_hook=__snake_case						)

						# We'll offload the last model manually.
						lowerCAmelCase__      :		List[Any]    							=      hook







					@property
					# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
					def 			__lowerCAmelCase					(			self     :							Optional[Any]						):
						if not hasattr(self.unet  ,'''_hf_hook'''						):
							return self.device
						for module in self.unet.modules():
							if (
							    hasattr(__snake_case  ,'''_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







					@torch.no_grad()
					@replace_example_docstring(__snake_case						)
					def __call__(			self     :							List[Any]  ,lowercase_     :							Union[torch.FloatTensor, List[torch.FloatTensor]]  ,lowercase_     :							Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]]  ,lowercase_     :							Union[torch.FloatTensor, List[torch.FloatTensor]]  ,lowercase_     :							int = 5_1_2  ,lowercase_     :							int = 5_1_2  ,lowercase_     :							int = 1_0_0  ,lowercase_     :							float = 4.0  ,lowercase_     :							float = 0.3  ,lowercase_     :							int = 1  ,lowercase_     :							Optional[Union[torch.Generator, List[torch.Generator]]] = None  ,lowercase_     :							Optional[str] = "pil"  ,lowercase_     :							bool = True  ,):
						lowerCAmelCase__      :		Tuple    							=      self._execution_device

						lowerCAmelCase__      :		str    							=      guidance_scale > 1.0

						if isinstance(__snake_case  ,__snake_case						):
							lowerCAmelCase__      :		Optional[int]    							=      torch.cat(__snake_case  ,dim=0						)
						lowerCAmelCase__      :		Any    							=      image_embeds.shape[0]
						if isinstance(__snake_case  ,__snake_case						):
							lowerCAmelCase__      :		str    							=      torch.cat(__snake_case  ,dim=0						)

						if do_classifier_free_guidance:
							lowerCAmelCase__      :		List[str]    							=      image_embeds.repeat_interleave(__snake_case  ,dim=0						)
							lowerCAmelCase__      :		Optional[int]    							=      negative_image_embeds.repeat_interleave(__snake_case  ,dim=0						)

						lowerCAmelCase__      :		str    							=      torch.cat([negative_image_embeds, image_embeds]  ,dim=0						).to(dtype=self.unet.dtype  ,device=__snake_case						)

						if not isinstance(__snake_case  ,__snake_case						):
							lowerCAmelCase__      :		Dict    							=      [image]
						if not all(isinstance(__snake_case  ,(PIL.Image.Image, torch.Tensor)						) for i in image						):
							raise ValueError(
							    F'Input is in incorrect format: {[type(__snake_case						) for i in image]}. Currently, we only support  PIL image and pytorch tensor'						)

						lowerCAmelCase__      :		List[Any]    							=      torch.cat([prepare_image(__snake_case  ,__snake_case  ,__snake_case						) for i in image]  ,dim=0						)
						lowerCAmelCase__      :		Optional[Any]    							=      image.to(dtype=image_embeds.dtype  ,device=__snake_case						)

						lowerCAmelCase__      :		Tuple    							=      self.movq.encode(__snake_case						)["""latents"""]
						lowerCAmelCase__      :		str    							=      latents.repeat_interleave(__snake_case  ,dim=0						)
						self.scheduler.set_timesteps(__snake_case  ,device=__snake_case						)
						lowerCAmelCase__      :		Tuple    							=      self.get_timesteps(__snake_case  ,__snake_case  ,__snake_case						)
						lowerCAmelCase__      :		Tuple    							=      timesteps[:1].repeat(batch_size * num_images_per_prompt						)
						lowerCAmelCase__      :		str    							=      downscale_height_and_width(__snake_case  ,__snake_case  ,self.movq_scale_factor						)
						lowerCAmelCase__      :		List[Any]    							=      self.prepare_latents(
						    __snake_case  ,__snake_case  ,__snake_case  ,__snake_case  ,image_embeds.dtype  ,__snake_case  ,__snake_case						)
						for i, t in enumerate(self.progress_bar(__snake_case						)						):
							# expand the latents if we are doing classifier free guidance
							lowerCAmelCase__      :		Union[str, Any]    							=      torch.cat([latents] * 2						) if do_classifier_free_guidance else latents

							lowerCAmelCase__      :		Optional[Any]    							=      {"""image_embeds""": image_embeds}
							lowerCAmelCase__      :		str    							=      self.unet(
							    sample=__snake_case  ,timestep=__snake_case  ,encoder_hidden_states=__snake_case  ,added_cond_kwargs=__snake_case  ,return_dict=__snake_case  ,)[0]

							if do_classifier_free_guidance:
								lowerCAmelCase__      :		List[Any]    							=      noise_pred.split(latents.shape[1]  ,dim=1						)
								lowerCAmelCase__      :		Optional[int]    							=      noise_pred.chunk(2						)
								lowerCAmelCase__      :		str    							=      variance_pred.chunk(2						)
								lowerCAmelCase__      :		int    							=      noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
								lowerCAmelCase__      :		Optional[Any]    							=      torch.cat([noise_pred, variance_pred_text]  ,dim=1						)

							if not (
							    hasattr(self.scheduler.config  ,'''variance_type'''						)
							    and self.scheduler.config.variance_type in ["learned", "learned_range"]
							):
								lowerCAmelCase__      :		str    							=      noise_pred.split(latents.shape[1]  ,dim=1						)

							# compute the previous noisy sample x_t -> x_t-1
							lowerCAmelCase__      :		List[str]    							=      self.scheduler.step(
							    __snake_case  ,__snake_case  ,__snake_case  ,generator=__snake_case  ,)[0]

						# post-processing
						lowerCAmelCase__      :		Any    							=      self.movq.decode(__snake_case  ,force_not_quantize=__snake_case						)["""sample"""]

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

						if output_type in ["np", "pil"]:
							lowerCAmelCase__      :		Any    							=      image * 0.5 + 0.5
							lowerCAmelCase__      :		int    							=      image.clamp(0  ,1						)
							lowerCAmelCase__      :		Union[str, Any]    							=      image.cpu().permute(0  ,2  ,3  ,1						).float().numpy()

						if output_type == "pil":
							lowerCAmelCase__      :		Dict    							=      self.numpy_to_pil(__snake_case						)

						if not return_dict:
							return (image,)

						return ImagePipelineOutput(images=__snake_case						)












"""simple docstring"""





import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers.models.esm.modeling_esmfold import EsmForProteinFolding



class       __A		:

					def __init__(			self  :      str     ,		__snake_case  :      int     ,		__snake_case  :      Dict=1_3     ,		__snake_case  :      Dict=7     ,		__snake_case  :      str=False     ,		__snake_case  :      Dict=True     ,		__snake_case  :      Tuple=False     ,		__snake_case  :      List[Any]=False     ,		__snake_case  :      Dict=1_9     ,		__snake_case  :      Dict=3_2     ,		__snake_case  :      Union[str, Any]=5     ,		__snake_case  :      List[Any]=4     ,		__snake_case  :      List[Any]=3_7     ,		__snake_case  :      Union[str, Any]="gelu"     ,		__snake_case  :      List[str]=0.1     ,		__snake_case  :      Union[str, Any]=0.1     ,		__snake_case  :      List[str]=5_1_2     ,		__snake_case  :      List[str]=1_6     ,		__snake_case  :      Tuple=2     ,		__snake_case  :      Optional[Any]=0.02     ,		__snake_case  :      str=3     ,		__snake_case  :      List[str]=4     ,		__snake_case  :      Optional[int]=None     ,		)			->							Optional[int]:
											__magic_name__:	Any							=       parent
											__magic_name__:	Optional[Any]							=       batch_size
											__magic_name__:	Optional[Any]							=       seq_length
											__magic_name__:	Optional[Any]							=       is_training
											__magic_name__:	str							=       use_input_mask
											__magic_name__:	Optional[Any]							=       use_token_type_ids
											__magic_name__:	List[str]							=       use_labels
											__magic_name__:	List[str]							=       vocab_size
											__magic_name__:	Union[str, Any]							=       hidden_size
											__magic_name__:	List[Any]							=       num_hidden_layers
											__magic_name__:	Dict							=       num_attention_heads
											__magic_name__:	int							=       intermediate_size
											__magic_name__:	List[Any]							=       hidden_act
											__magic_name__:	int							=       hidden_dropout_prob
											__magic_name__:	List[str]							=       attention_probs_dropout_prob
											__magic_name__:	Tuple							=       max_position_embeddings
											__magic_name__:	Any							=       type_vocab_size
											__magic_name__:	Union[str, Any]							=       type_sequence_label_size
											__magic_name__:	List[str]							=       initializer_range
											__magic_name__:	Optional[Any]							=       num_labels
											__magic_name__:	List[str]							=       num_choices
											__magic_name__:	Tuple							=       scope

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Any:
											__magic_name__:	Union[str, Any]							=       ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size					)

											__magic_name__:	Dict							=       None
											if self.use_input_mask:
																	__magic_name__:	Optional[int]							=       random_attention_mask([self.batch_size, self.seq_length]					)

											__magic_name__:	str							=       None
											__magic_name__:	Optional[Any]							=       None
											__magic_name__:	int							=       None
											if self.use_labels:
																	__magic_name__:	List[Any]							=       ids_tensor([self.batch_size]     ,		self.type_sequence_label_size					)
																	__magic_name__:	str							=       ids_tensor([self.batch_size, self.seq_length]     ,		self.num_labels					)
																	__magic_name__:	Dict							=       ids_tensor([self.batch_size]     ,		self.num_choices					)

											__magic_name__:	Dict							=       self.get_config()

											return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels

					def   lowerCamelCase__   (			self  :      int					)			->							Any:
											__magic_name__:	List[Any]							=       EsmConfig(
											    vocab_size=3_3     ,		hidden_size=self.hidden_size     ,		pad_token_id=1     ,		num_hidden_layers=self.num_hidden_layers     ,		num_attention_heads=self.num_attention_heads     ,		intermediate_size=self.intermediate_size     ,		hidden_act=self.hidden_act     ,		hidden_dropout_prob=self.hidden_dropout_prob     ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,		max_position_embeddings=self.max_position_embeddings     ,		type_vocab_size=self.type_vocab_size     ,		initializer_range=self.initializer_range     ,		is_folding_model=__snake_case     ,		esmfold_config={"""trunk""": {"""num_blocks""": 2}, """fp16_esm""": False}     ,		)
											return config

					def   lowerCamelCase__   (			self  :      Optional[int]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Optional[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      List[Any]     ,		__snake_case  :      Any     ,		__snake_case  :      Union[str, Any]					)			->							Optional[Any]:
											__magic_name__:	str							=       EsmForProteinFolding(config=__snake_case					).float()
											model.to(__snake_case					)
											model.eval()
											__magic_name__:	str							=       model(__snake_case     ,		attention_mask=__snake_case					)
											__magic_name__:	Any							=       model(__snake_case					)
											__magic_name__:	Dict							=       model(__snake_case					)

											self.parent.assertEqual(result.positions.shape     ,		(8, self.batch_size, self.seq_length, 1_4, 3)					)
											self.parent.assertEqual(result.angles.shape     ,		(8, self.batch_size, self.seq_length, 7, 2)					)






					def   lowerCamelCase__   (			self  :      Any					)			->							int:
											__magic_name__:	str							=       self.prepare_config_and_inputs()
											(
											    (
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			(
											    __magic_name__
											),			
											):	Union[str, Any]							=       config_and_inputs
											__magic_name__:	Any							=       {"""input_ids""": input_ids, """attention_mask""": input_mask}
											return config, inputs_dict



@require_torch
class       __A		(   SCREAMING_SNAKE_CASE_     ,SCREAMING_SNAKE_CASE_     ,unittest.TestCase			):
					UpperCAmelCase__								=				False

					UpperCAmelCase__								=				(EsmForProteinFolding,) if is_torch_available() else ()
					UpperCAmelCase__								=				()
					UpperCAmelCase__								=				{} if is_torch_available() else {}
					UpperCAmelCase__								=				False

					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Optional[Any]:
											__magic_name__:	Optional[int]							=       EsmFoldModelTester(self					)
											__magic_name__:	Optional[Any]							=       ConfigTester(self     ,		config_class=__snake_case     ,		hidden_size=3_7					)

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Any:
											self.config_tester.run_common_tests()

					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											__magic_name__:	Tuple							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__snake_case					)

					@unittest.skip("""Does not support attention outputs"""					)
					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											pass

					@unittest.skip
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Tuple:
											pass

					@unittest.skip("""Esm does not support embedding resizing"""					)
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Optional[int]:
											pass

					@unittest.skip("""Esm does not support embedding resizing"""					)
					def   lowerCamelCase__   (			self  :      str					)			->							str:
											pass

					@unittest.skip("""ESMFold does not support passing input embeds!"""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							List[str]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Tuple:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold does not support head pruning."""					)
					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold does not output hidden states in the normal way."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[Any]:
											pass

					@unittest.skip("""ESMfold does not output hidden states in the normal way."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							int:
											pass

					@unittest.skip("""ESMFold only has one output format."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							str:
											pass

					@unittest.skip("""This test doesn't work for ESMFold and doesn't test core functionality"""					)
					def   lowerCamelCase__   (			self  :      List[Any]					)			->							Dict:
											pass

					@unittest.skip("""ESMFold does not support input chunking."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Any:
											pass

					@unittest.skip("""ESMFold doesn't respect you and it certainly doesn't respect your initialization arguments."""					)
					def   lowerCamelCase__   (			self  :      int					)			->							Union[str, Any]:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Any					)			->							Optional[Any]:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							int:
											pass

					@unittest.skip("""ESMFold doesn't support torchscript compilation."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							List[str]:
											pass

					@unittest.skip("""ESMFold doesn't support data parallel."""					)
					def   lowerCamelCase__   (			self  :      List[str]					)			->							str:
											pass






					@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""					)
					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							Dict:
											pass



@require_torch
class       __A		(   SCREAMING_SNAKE_CASE_			):

					@slow
					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							List[Any]:
											__magic_name__:	Any							=       EsmForProteinFolding.from_pretrained("""facebook/esmfold_v1"""					).float()
											model.eval()
											__magic_name__:	Optional[int]							=       torch.tensor([[0, 6, 4, 1_3, 5, 4, 1_6, 1_2, 1_1, 7, 2]]					)
											__magic_name__:	Dict							=       model(__snake_case					)["""positions"""]
											__magic_name__:	Tuple							=       torch.tensor([2.5828, 0.7993, -10.9334]     ,		dtype=torch.floataa					)
											self.assertTrue(torch.allclose(position_outputs[0, 0, 0, 0]     ,		__snake_case     ,		atol=1E-4					)					)



