




'''simple docstring'''







import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)





def 						snake_case_							(_a	:							Tuple    ,   _a	:							Tuple    ,   _a	:							Optional[int]     ):
    if isinstance(_a    ,   torch.Tensor     ):
        return image
    elif isinstance(_a    ,   PIL.Image.Image     ):
        UpperCAmelCase			       =		[image]

    if isinstance(image[0]    ,   PIL.Image.Image     ):
        UpperCAmelCase			       =		[np.array(i.resize((w, h)    ,   resample=PIL_INTERPOLATION['''lanczos''']     )     )[None, :] for i in image]
        UpperCAmelCase			       =		np.concatenate(_a    ,   axis=0     )
        UpperCAmelCase			       =		np.array(_a     ).astype(np.floataa     ) / 255.0
        UpperCAmelCase			       =		image.transpose(0    ,   3    ,   1    ,   2     )
        UpperCAmelCase			       =		2.0 * image - 1.0
        UpperCAmelCase			       =		torch.from_numpy(_a     )
    elif isinstance(image[0]    ,   torch.Tensor     ):
        UpperCAmelCase			       =		torch.cat(_a    ,   dim=0     )
    return image





def 						snake_case_							(_a	:							Optional[Any]    ,   _a	:							int    ,   _a	:							Union[str, Any]    ,   _a	:							int=0.9995     ):
    if not isinstance(_a    ,   np.ndarray     ):
        UpperCAmelCase			       =		True
        UpperCAmelCase			       =		va.device
        UpperCAmelCase			       =		va.cpu().numpy()
        UpperCAmelCase			       =		va.cpu().numpy()

    UpperCAmelCase			       =		np.sum(va * va / (np.linalg.norm(_a     ) * np.linalg.norm(_a     ))     )
    if np.abs(_a     ) > DOT_THRESHOLD:
        UpperCAmelCase			       =		(1 - t) * va + t * va
    else:
        UpperCAmelCase			       =		np.arccos(_a     )
        UpperCAmelCase			       =		np.sin(_a     )
        UpperCAmelCase			       =		theta_a * t
        UpperCAmelCase			       =		np.sin(_a     )
        UpperCAmelCase			       =		np.sin(theta_a - theta_t     ) / sin_theta_a
        UpperCAmelCase			       =		sin_theta_t / sin_theta_a
        UpperCAmelCase			       =		sa * va + sa * va

    if inputs_are_torch:
        UpperCAmelCase			       =		torch.from_numpy(_a     ).to(_a     )

    return va





def 						snake_case_							(_a	:							List[str]    ,   _a	:							int     ):
    UpperCAmelCase			       =		F.normalize(_a    ,   dim=-1     )
    UpperCAmelCase			       =		F.normalize(_a    ,   dim=-1     )
    return (x - y).norm(dim=-1     ).div(2     ).arcsin().pow(2     ).mul(2     )





def 						snake_case_							(_a	:							Dict    ,   _a	:							Optional[Any]     ):
    for param in model.parameters():
        UpperCAmelCase			       =		value







class 			_a  (	__a ):
       def __init__(	self						:	Optional[Any]   ,				lowercase						:	AutoencoderKL   ,				lowercase						:	CLIPTextModel   ,				lowercase						:	CLIPModel   ,				lowercase						:	CLIPTokenizer   ,				lowercase						:	UNetaDConditionModel   ,				lowercase						:	Union[PNDMScheduler, LMSDiscreteScheduler, DDIMScheduler, DPMSolverMultistepScheduler]   ,				lowercase						:	CLIPFeatureExtractor   ,				lowercase						:	Union[str, Any]=None   ,				lowercase						:	int=None   ,				lowercase						:	Union[str, Any]=None   ,				):



           '''simple docstring'''

           super().__init__()
           self.register_modules(
               vae=lowercase   ,				text_encoder=lowercase   ,				clip_model=lowercase   ,				tokenizer=lowercase   ,				unet=lowercase   ,				scheduler=lowercase   ,				feature_extractor=lowercase   ,				coca_model=lowercase   ,				coca_tokenizer=lowercase   ,				coca_transform=lowercase   ,				)
           UpperCAmelCase			       =		(
               feature_extractor.size
               if isinstance(feature_extractor.size   ,				lowercase				)
               else feature_extractor.size['''shortest_edge''']
           )
           UpperCAmelCase			       =		transforms.Normalize(mean=feature_extractor.image_mean   ,				std=feature_extractor.image_std				)
           set_requires_grad(self.text_encoder   ,				lowercase				)
           set_requires_grad(self.clip_model   ,				lowercase				)
       def     A      (	self						:	str   ,				lowercase						:	Optional[Union[str, int]] = "auto"				):



           '''simple docstring'''

           if slice_size == "auto":
               # half the attention head size is usually a good trade-off between
               # speed and memory
               UpperCAmelCase			       =		self.unet.config.attention_head_dim // 2
           self.unet.set_attention_slice(lowercase				)
       def     A      (	self						:	Any				):



           '''simple docstring'''

           self.enable_attention_slicing(lowercase				)
       def     A      (	self						:	Tuple				):



           '''simple docstring'''

           set_requires_grad(self.vae   ,				lowercase				)
       def     A      (	self						:	str				):



           '''simple docstring'''

           set_requires_grad(self.vae   ,				lowercase				)
       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           set_requires_grad(self.unet   ,				lowercase				)
       def     A      (	self						:	Any				):



           '''simple docstring'''

           set_requires_grad(self.unet   ,				lowercase				)
       def     A      (	self						:	Any   ,				lowercase						:	Optional[int]   ,				lowercase						:	Optional[Any]   ,				lowercase						:	int				):



           '''simple docstring'''

           UpperCAmelCase			       =		min(int(num_inference_steps * strength				)   ,				lowercase				)

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

           return timesteps, num_inference_steps - t_start
       def     A      (	self						:	Optional[Any]   ,				lowercase						:	List[str]   ,				lowercase						:	Tuple   ,				lowercase						:	Any   ,				lowercase						:	List[str]   ,				lowercase						:	str   ,				lowercase						:	Dict=None				):



           '''simple docstring'''

           if not isinstance(lowercase   ,				torch.Tensor				):
               raise ValueError(f"`image` has to be of type `torch.Tensor` but is {type(lowercase				)}"				)

           UpperCAmelCase			       =		image.to(device=lowercase   ,				dtype=lowercase				)

           if isinstance(lowercase   ,				lowercase				):
               UpperCAmelCase			       =		[
                   self.vae.encode(image[i : i + 1]				).latent_dist.sample(generator[i]				) for i in range(lowercase				)
               ]
               UpperCAmelCase			       =		torch.cat(lowercase   ,				dim=0				)
           else:
               UpperCAmelCase			       =		self.vae.encode(lowercase				).latent_dist.sample(lowercase				)

           # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
           UpperCAmelCase			       =		0.1_8215 * init_latents
           UpperCAmelCase			       =		init_latents.repeat_interleave(lowercase   ,				dim=0				)

           UpperCAmelCase			       =		randn_tensor(init_latents.shape   ,				generator=lowercase   ,				device=lowercase   ,				dtype=lowercase				)

           # get latents
           UpperCAmelCase			       =		self.scheduler.add_noise(lowercase   ,				lowercase   ,				lowercase				)
           UpperCAmelCase			       =		init_latents

           return latents
       def     A      (	self						:	Union[str, Any]   ,				lowercase						:	Tuple				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.coca_transform(lowercase				).unsqueeze(0				)
           with torch.no_grad(), torch.cuda.amp.autocast():
               UpperCAmelCase			       =		self.coca_model.generate(transformed_image.to(device=self.device   ,				dtype=self.coca_model.dtype				)				)
           UpperCAmelCase			       =		self.coca_tokenizer.decode(generated[0].cpu().numpy()				)
           return generated.split('''<end_of_text>'''				)[0].replace('''<start_of_text>'''   ,				''''''				).rstrip(''' .,'''				)
       def     A      (	self						:	Union[str, Any]   ,				lowercase						:	Tuple   ,				lowercase						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		self.feature_extractor.preprocess(lowercase				)
           UpperCAmelCase			       =		torch.from_numpy(clip_image_input['''pixel_values'''][0]				).unsqueeze(0				).to(self.device				).half()
           UpperCAmelCase			       =		self.clip_model.get_image_features(lowercase				)
           UpperCAmelCase			       =		image_embeddings_clip / image_embeddings_clip.norm(p=2   ,				dim=-1   ,				keepdim=lowercase				)
           UpperCAmelCase			       =		image_embeddings_clip.repeat_interleave(lowercase   ,				dim=0				)
           return image_embeddings_clip
       @torch.enable_grad()
       def     A      (	self						:	Any   ,				lowercase						:	List[str]   ,				lowercase						:	Optional[Any]   ,				lowercase						:	Dict   ,				lowercase						:	Any   ,				lowercase						:	List[str]   ,				lowercase						:	Union[str, Any]   ,				lowercase						:	List[Any]   ,				):



           '''simple docstring'''

           UpperCAmelCase			       =		latents.detach().requires_grad_()

           UpperCAmelCase			       =		self.scheduler.scale_model_input(lowercase   ,				lowercase				)

           # predict the noise residual
           UpperCAmelCase			       =		self.unet(lowercase   ,				lowercase   ,				encoder_hidden_states=lowercase				).sample

           if isinstance(self.scheduler   ,				(PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)				):
               UpperCAmelCase			       =		self.scheduler.alphas_cumprod[timestep]
               UpperCAmelCase			       =		1 - alpha_prod_t
               # compute predicted original sample from predicted noise also called
               # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
               UpperCAmelCase			       =		(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

               UpperCAmelCase			       =		torch.sqrt(lowercase				)
               UpperCAmelCase			       =		pred_original_sample * (fac) + latents * (1 - fac)
           elif isinstance(self.scheduler   ,				lowercase				):
               UpperCAmelCase			       =		self.scheduler.sigmas[index]
               UpperCAmelCase			       =		latents - sigma * noise_pred
           else:
               raise ValueError(f"scheduler type {type(self.scheduler				)} not supported"				)

           # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
           UpperCAmelCase			       =		1 / 0.1_8215 * sample
           UpperCAmelCase			       =		self.vae.decode(lowercase				).sample
           UpperCAmelCase			       =		(image / 2 + 0.5).clamp(0   ,				1				)

           UpperCAmelCase			       =		transforms.Resize(self.feature_extractor_size				)(lowercase				)
           UpperCAmelCase			       =		self.normalize(lowercase				).to(latents.dtype				)

           UpperCAmelCase			       =		self.clip_model.get_image_features(lowercase				)
           UpperCAmelCase			       =		image_embeddings_clip / image_embeddings_clip.norm(p=2   ,				dim=-1   ,				keepdim=lowercase				)

           UpperCAmelCase			       =		spherical_dist_loss(lowercase   ,				lowercase				).mean() * clip_guidance_scale

           UpperCAmelCase			       =		-torch.autograd.grad(lowercase   ,				lowercase				)[0]

           if isinstance(self.scheduler   ,				lowercase				):
               UpperCAmelCase			       =		latents.detach() + grads * (sigma**2)
               UpperCAmelCase			       =		noise_pred_original
           else:
               UpperCAmelCase			       =		noise_pred_original - torch.sqrt(lowercase				) * grads
           return noise_pred, latents







       @torch.no_grad()
       def __call__(	self						:	List[str]   ,				lowercase						:	Union[torch.FloatTensor, PIL.Image.Image]   ,				lowercase						:	Union[torch.FloatTensor, PIL.Image.Image]   ,				lowercase						:	Optional[str] = None   ,				lowercase						:	Optional[str] = None   ,				lowercase						:	Optional[int] = 512   ,				lowercase						:	Optional[int] = 512   ,				lowercase						:	float = 0.6   ,				lowercase						:	Optional[int] = 50   ,				lowercase						:	Optional[float] = 7.5   ,				lowercase						:	Optional[int] = 1   ,				lowercase						:	float = 0.0   ,				lowercase						:	Optional[float] = 100   ,				lowercase						:	Optional[torch.Generator] = None   ,				lowercase						:	Optional[str] = "pil"   ,				lowercase						:	bool = True   ,				lowercase						:	float = 0.8   ,				lowercase						:	float = 0.1   ,				lowercase						:	float = 0.1   ,				):



           '''simple docstring'''

           if isinstance(lowercase   ,				lowercase				) and len(lowercase				) != batch_size:
               raise ValueError(f"You have passed {batch_size} batch_size, but only {len(lowercase				)} generators."				)

           if height % 8 != 0 or width % 8 != 0:
               raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}."				)

           if isinstance(lowercase   ,				torch.Generator				) and batch_size > 1:
               UpperCAmelCase			       =		[generator] + [None] * (batch_size - 1)

           UpperCAmelCase			       =		[
               ('''model''', self.coca_model is None),
               ('''tokenizer''', self.coca_tokenizer is None),
               ('''transform''', self.coca_transform is None),
           ]
           UpperCAmelCase			       =		[x[0] for x in coca_is_none if x[1]]
           UpperCAmelCase			       =		''', '''.join(lowercase				)
           # generate prompts with coca model if prompt is None
           if content_prompt is None:
               if len(lowercase				):
                   raise ValueError(
                       f"Content prompt is None and CoCa [{coca_is_none_str}] is None."
                       f"Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."				)
               UpperCAmelCase			       =		self.get_image_description(lowercase				)
           if style_prompt is None:
               if len(lowercase				):
                   raise ValueError(
                       f"Style prompt is None and CoCa [{coca_is_none_str}] is None."
                       f" Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline."				)
               UpperCAmelCase			       =		self.get_image_description(lowercase				)

           # get prompt text embeddings for content and style
           UpperCAmelCase			       =		self.tokenizer(
               lowercase   ,				padding='''max_length'''   ,				max_length=self.tokenizer.model_max_length   ,				truncation=lowercase   ,				return_tensors='''pt'''   ,				)
           UpperCAmelCase			       =		self.text_encoder(content_text_input.input_ids.to(self.device				)				)[0]

           UpperCAmelCase			       =		self.tokenizer(
               lowercase   ,				padding='''max_length'''   ,				max_length=self.tokenizer.model_max_length   ,				truncation=lowercase   ,				return_tensors='''pt'''   ,				)
           UpperCAmelCase			       =		self.text_encoder(style_text_input.input_ids.to(self.device				)				)[0]

           UpperCAmelCase			       =		slerp(lowercase   ,				lowercase   ,				lowercase				)

           # duplicate text embeddings for each generation per prompt
           UpperCAmelCase			       =		text_embeddings.repeat_interleave(lowercase   ,				dim=0				)

           # set timesteps
           UpperCAmelCase			       =		'''offset''' in set(inspect.signature(self.scheduler.set_timesteps				).parameters.keys()				)
           UpperCAmelCase			       =		{}
           if accepts_offset:
               UpperCAmelCase			       =		1

           self.scheduler.set_timesteps(lowercase   ,				**lowercase				)
           # Some schedulers like PNDM have timesteps as arrays
           # It's more optimized to move all timesteps to correct device beforehand
           self.scheduler.timesteps.to(self.device				)

           UpperCAmelCase       ,     UpperCAmelCase			       =		self.get_timesteps(lowercase   ,				lowercase   ,				self.device				)
           UpperCAmelCase			       =		timesteps[:1].repeat(lowercase				)

           # Preprocess image
           UpperCAmelCase			       =		preprocess(lowercase   ,				lowercase   ,				lowercase				)
           UpperCAmelCase			       =		self.prepare_latents(
               lowercase   ,				lowercase   ,				lowercase   ,				text_embeddings.dtype   ,				self.device   ,				lowercase				)

           UpperCAmelCase			       =		preprocess(lowercase   ,				lowercase   ,				lowercase				)
           UpperCAmelCase			       =		self.prepare_latents(
               lowercase   ,				lowercase   ,				lowercase   ,				text_embeddings.dtype   ,				self.device   ,				lowercase				)

           UpperCAmelCase			       =		slerp(lowercase   ,				lowercase   ,				lowercase				)

           if clip_guidance_scale > 0:
               UpperCAmelCase			       =		self.get_clip_image_embeddings(lowercase   ,				lowercase				)
               UpperCAmelCase			       =		self.get_clip_image_embeddings(lowercase   ,				lowercase				)
               UpperCAmelCase			       =		slerp(
                   lowercase   ,				lowercase   ,				lowercase				)

           # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
           # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
           # corresponds to doing no classifier free guidance.
           UpperCAmelCase			       =		guidance_scale > 1.0
           # get unconditional embeddings for classifier free guidance
           if do_classifier_free_guidance:
               UpperCAmelCase			       =		content_text_input.input_ids.shape[-1]
               UpperCAmelCase			       =		self.tokenizer(['''''']   ,				padding='''max_length'''   ,				max_length=lowercase   ,				return_tensors='''pt'''				)
               UpperCAmelCase			       =		self.text_encoder(uncond_input.input_ids.to(self.device				)				)[0]
               # duplicate unconditional embeddings for each generation per prompt
               UpperCAmelCase			       =		uncond_embeddings.repeat_interleave(lowercase   ,				dim=0				)

               # 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
               UpperCAmelCase			       =		torch.cat([uncond_embeddings, text_embeddings]				)

           # get the initial random noise unless the user supplied it

           # Unlike in other pipelines, latents need to be generated in the target device
           # for 1-to-1 results reproducibility with the CompVis implementation.
           # However this currently doesn't work in `mps`.
           UpperCAmelCase			       =		(batch_size, self.unet.config.in_channels, height // 8, width // 8)
           UpperCAmelCase			       =		text_embeddings.dtype
           if latents is None:
               if self.device.type == "mps":
                   # randn does not work reproducibly on mps
                   UpperCAmelCase			       =		torch.randn(lowercase   ,				generator=lowercase   ,				device='''cpu'''   ,				dtype=lowercase				).to(
                       self.device				)
               else:
                   UpperCAmelCase			       =		torch.randn(lowercase   ,				generator=lowercase   ,				device=self.device   ,				dtype=lowercase				)
           else:
               if latents.shape != latents_shape:
                   raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}"				)
               UpperCAmelCase			       =		latents.to(self.device				)

           # scale the initial noise by the standard deviation required by the scheduler
           UpperCAmelCase			       =		latents * self.scheduler.init_noise_sigma

           # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
           # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
           # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
           # and should be between [0, 1]
           UpperCAmelCase			       =		'''eta''' in set(inspect.signature(self.scheduler.step				).parameters.keys()				)
           UpperCAmelCase			       =		{}
           if accepts_eta:
               UpperCAmelCase			       =		eta

           # check if the scheduler accepts generator
           UpperCAmelCase			       =		'''generator''' in set(inspect.signature(self.scheduler.step				).parameters.keys()				)
           if accepts_generator:
               UpperCAmelCase			       =		generator

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

                   # predict the noise residual
                   UpperCAmelCase			       =		self.unet(lowercase   ,				lowercase   ,				encoder_hidden_states=lowercase				).sample

                   # perform classifier free guidance
                   if do_classifier_free_guidance:
                       UpperCAmelCase       ,     UpperCAmelCase			       =		noise_pred.chunk(2				)
                       UpperCAmelCase			       =		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

                   # perform clip guidance
                   if clip_guidance_scale > 0:
                       UpperCAmelCase			       =		(
                           text_embeddings.chunk(2				)[1] if do_classifier_free_guidance else text_embeddings
                       )
                       UpperCAmelCase       ,     UpperCAmelCase			       =		self.cond_fn(
                           lowercase   ,				lowercase   ,				lowercase   ,				lowercase   ,				lowercase   ,				lowercase   ,				lowercase   ,				)

                   # compute the previous noisy sample x_t -> x_t-1
                   UpperCAmelCase			       =		self.scheduler.step(lowercase   ,				lowercase   ,				lowercase   ,				**lowercase				).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
           UpperCAmelCase			       =		1 / 0.1_8215 * latents
           UpperCAmelCase			       =		self.vae.decode(lowercase				).sample

           UpperCAmelCase			       =		(image / 2 + 0.5).clamp(0   ,				1				)
           UpperCAmelCase			       =		image.cpu().permute(0   ,				2   ,				3   ,				1				).numpy()

           if output_type == "pil":
               UpperCAmelCase			       =		self.numpy_to_pil(lowercase				)

           if not return_dict:
               return (image, None)

           return StableDiffusionPipelineOutput(images=lowercase   ,				nsfw_content_detected=lowercase				)










'''simple docstring'''







from ..utils import DummyObject, requires_backends


class 			_a  (	metaclass=__a ):
       __a				:     int   				=					["""flax""", """transformers"""]
       def __init__(	self						:	Optional[Any]   ,				*lowercase						:	str   ,				**lowercase						:	List[Any]				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	List[Any]   ,				**lowercase						:	List[str]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	Tuple   ,				**lowercase						:	int				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)






class 			_a  (	metaclass=__a ):
       __a				:     int   				=					["""flax""", """transformers"""]
       def __init__(	self						:	int   ,				*lowercase						:	Tuple   ,				**lowercase						:	Dict				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	List[str]   ,				*lowercase						:	Optional[int]   ,				**lowercase						:	List[Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Dict   ,				*lowercase						:	Union[str, Any]   ,				**lowercase						:	Union[str, Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)






class 			_a  (	metaclass=__a ):
       __a				:     int   				=					["""flax""", """transformers"""]
       def __init__(	self						:	Optional[int]   ,				*lowercase						:	Union[str, Any]   ,				**lowercase						:	Any				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	Tuple   ,				**lowercase						:	Any				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Any   ,				*lowercase						:	Dict   ,				**lowercase						:	Optional[Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)






class 			_a  (	metaclass=__a ):
       __a				:     Any   				=					["""flax""", """transformers"""]
       def __init__(	self						:	Any   ,				*lowercase						:	Optional[Any]   ,				**lowercase						:	Optional[int]				):



           '''simple docstring'''

           requires_backends(self   ,				['''flax''', '''transformers''']				)
       @classmethod
       def     A      (	cls						:	Dict   ,				*lowercase						:	Optional[Any]   ,				**lowercase						:	Optional[Any]				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)







       @classmethod
       def     A      (	cls						:	Union[str, Any]   ,				*lowercase						:	str   ,				**lowercase						:	Any				):



           '''simple docstring'''

           requires_backends(cls   ,				['''flax''', '''transformers''']				)




