"""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 			UpperCAmelCase__       (				lowerCAmelCase__     :Optional[int]					,		lowerCAmelCase__     :Any					,		lowerCAmelCase__     :str		) ->    List[str]:
      '''simple docstring'''


      if isinstance(lowerCAmelCase__					,		torch.Tensor		):
            return image
      elif isinstance(lowerCAmelCase__					,		PIL.Image.Image		):
            lowercase														=	[image]

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


def 			UpperCAmelCase__       (				lowerCAmelCase__     :Tuple					,		lowerCAmelCase__     :Dict					,		lowerCAmelCase__     :Union[str, Any]					,		lowerCAmelCase__     :Optional[Any]=0.9_995		) ->    Any:
      '''simple docstring'''


      if not isinstance(lowerCAmelCase__					,		np.ndarray		):
            lowercase														=	True
            lowercase														=	va.device
            lowercase														=	va.cpu().numpy()
            lowercase														=	va.cpu().numpy()

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

      if inputs_are_torch:
            lowercase														=	torch.from_numpy(lowerCAmelCase__		).to(lowerCAmelCase__		)

      return va


def 			UpperCAmelCase__       (				lowerCAmelCase__     :Optional[int]					,		lowerCAmelCase__     :Optional[Any]		) ->    Dict:
      '''simple docstring'''


      lowercase														=	F.normalize(lowerCAmelCase__					,		dim=-1		)
      lowercase														=	F.normalize(lowerCAmelCase__					,		dim=-1		)
      return (x - y).norm(dim=-1		).div(2		).arcsin().pow(2		).mul(2		)


def 			UpperCAmelCase__       (				lowerCAmelCase__     :int					,		lowerCAmelCase__     :Any		) ->    Tuple:
      '''simple docstring'''


      for param in model.parameters():
            lowercase														=	value






class  _A						(       lowerCAmelCase	):

      def __init__(						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase=None		,       __lowerCAmelCase=None		,       __lowerCAmelCase=None		,       ):







            """simple docstring"""



            super().__init__()
            self.register_modules(
                vae=__lowerCAmelCase		,       text_encoder=__lowerCAmelCase		,       clip_model=__lowerCAmelCase		,       tokenizer=__lowerCAmelCase		,       unet=__lowerCAmelCase		,       scheduler=__lowerCAmelCase		,       feature_extractor=__lowerCAmelCase		,       coca_model=__lowerCAmelCase		,       coca_tokenizer=__lowerCAmelCase		,       coca_transform=__lowerCAmelCase		,       )
            lowercase														=	(
                feature_extractor.size
                if isinstance(feature_extractor.size		,       __lowerCAmelCase						)
                else feature_extractor.size["""shortest_edge"""]
            )
            lowercase														=	transforms.Normalize(mean=feature_extractor.image_mean		,       std=feature_extractor.image_std						)
            set_requires_grad(self.text_encoder		,       __lowerCAmelCase						)
            set_requires_grad(self.clip_model		,       __lowerCAmelCase						)

      def 				A__       (						self		,       __lowerCAmelCase = "auto"						):







            """simple docstring"""



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

      def 				A__       (						self						):







            """simple docstring"""



            self.enable_attention_slicing(__lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            set_requires_grad(self.vae		,       __lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            set_requires_grad(self.vae		,       __lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            set_requires_grad(self.unet		,       __lowerCAmelCase						)

      def 				A__       (						self						):







            """simple docstring"""



            set_requires_grad(self.unet		,       __lowerCAmelCase						)

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



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

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

            return timesteps, num_inference_steps - t_start

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase=None						):







            """simple docstring"""



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

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

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

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

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

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

            return latents

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	self.coca_transform(__lowerCAmelCase						).unsqueeze(0						)
            with torch.no_grad(), torch.cuda.amp.autocast():
                  lowercase														=	self.coca_model.generate(transformed_image.to(device=self.device		,       dtype=self.coca_model.dtype						)						)
            lowercase														=	self.coca_tokenizer.decode(generated[0].cpu().numpy()						)
            return generated.split("""<end_of_text>"""						)[0].replace("""<start_of_text>"""		,       """"""						).rstrip(""" .,"""						)

      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	self.feature_extractor.preprocess(__lowerCAmelCase						)
            lowercase														=	torch.from_numpy(clip_image_input["""pixel_values"""][0]						).unsqueeze(0						).to(self.device						).half()
            lowercase														=	self.clip_model.get_image_features(__lowerCAmelCase						)
            lowercase														=	image_embeddings_clip / image_embeddings_clip.norm(p=2		,       dim=-1		,       keepdim=__lowerCAmelCase						)
            lowercase														=	image_embeddings_clip.repeat_interleave(__lowerCAmelCase		,       dim=0						)
            return image_embeddings_clip

      @torch.enable_grad()
      def 				A__       (						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase		,       ):







            """simple docstring"""



            lowercase														=	latents.detach().requires_grad_()

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

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

            if isinstance(self.scheduler		,       (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)						):
                  lowercase														=	self.scheduler.alphas_cumprod[timestep]
                  lowercase														=	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
                  lowercase														=	(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

                  lowercase														=	torch.sqrt(__lowerCAmelCase						)
                  lowercase														=	pred_original_sample * (fac) + latents * (1 - fac)
            elif isinstance(self.scheduler		,       __lowerCAmelCase						):
                  lowercase														=	self.scheduler.sigmas[index]
                  lowercase														=	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
            lowercase														=	1 / 0.1_8_2_1_5 * sample
            lowercase														=	self.vae.decode(__lowerCAmelCase						).sample
            lowercase														=	(image / 2 + 0.5).clamp(0		,       1						)

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

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

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

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

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







      @torch.no_grad()
      def __call__(						self		,       __lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase = None		,       __lowerCAmelCase = None		,       __lowerCAmelCase = 512		,       __lowerCAmelCase = 512		,       __lowerCAmelCase = 0.6		,       __lowerCAmelCase = 50		,       __lowerCAmelCase = 7.5		,       __lowerCAmelCase = 1		,       __lowerCAmelCase = 0.0		,       __lowerCAmelCase = 100		,       __lowerCAmelCase = None		,       __lowerCAmelCase = "pil"		,       __lowerCAmelCase = True		,       __lowerCAmelCase = 0.8		,       __lowerCAmelCase = 0.1		,       __lowerCAmelCase = 0.1		,       ):







            """simple docstring"""



            if isinstance(__lowerCAmelCase		,       __lowerCAmelCase						) and len(__lowerCAmelCase						) != batch_size:
                  raise ValueError(f'You have passed {batch_size} batch_size, but only {len(__lowerCAmelCase						)} 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(__lowerCAmelCase		,       torch.Generator						) and batch_size > 1:
                  lowercase														=	[generator] + [None] * (batch_size - 1)

            lowercase														=	[
                ("""model""", self.coca_model is None),
                ("""tokenizer""", self.coca_tokenizer is None),
                ("""transform""", self.coca_transform is None),
            ]
            lowercase														=	[x[0] for x in coca_is_none if x[1]]
            lowercase														=	""", """.join(__lowerCAmelCase						)
            # generate prompts with coca model if prompt is None
            if content_prompt is None:
                  if len(__lowerCAmelCase						):
                        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.'						)
                  lowercase														=	self.get_image_description(__lowerCAmelCase						)
            if style_prompt is None:
                  if len(__lowerCAmelCase						):
                        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.'						)
                  lowercase														=	self.get_image_description(__lowerCAmelCase						)

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

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

            lowercase														=	slerp(__lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						)

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

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

            self.scheduler.set_timesteps(__lowerCAmelCase		,       **__lowerCAmelCase						)
            # 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						)

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

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

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

            lowercase														=	slerp(__lowerCAmelCase		,       __lowerCAmelCase		,       __lowerCAmelCase						)

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

            # 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.
            lowercase														=	guidance_scale > 1.0
            # get unconditional embeddings for classifier free guidance
            if do_classifier_free_guidance:
                  lowercase														=	content_text_input.input_ids.shape[-1]
                  lowercase														=	self.tokenizer([""""""]		,       padding="""max_length"""		,       max_length=__lowerCAmelCase		,       return_tensors="""pt"""						)
                  lowercase														=	self.text_encoder(uncond_input.input_ids.to(self.device						)						)[0]
                  # duplicate unconditional embeddings for each generation per prompt
                  lowercase														=	uncond_embeddings.repeat_interleave(__lowerCAmelCase		,       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
                  lowercase														=	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`.
            lowercase														=	(batch_size, self.unet.config.in_channels, height // 8, width // 8)
            lowercase														=	text_embeddings.dtype
            if latents is None:
                  if self.device.type == "mps":
                        # randn does not work reproducibly on mps
                        lowercase														=	torch.randn(__lowerCAmelCase		,       generator=__lowerCAmelCase		,       device="""cpu"""		,       dtype=__lowerCAmelCase						).to(
                            self.device						)
                  else:
                        lowercase														=	torch.randn(__lowerCAmelCase		,       generator=__lowerCAmelCase		,       device=self.device		,       dtype=__lowerCAmelCase						)
            else:
                  if latents.shape != latents_shape:
                        raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {latents_shape}'						)
                  lowercase														=	latents.to(self.device						)

            # scale the initial noise by the standard deviation required by the scheduler
            lowercase														=	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]
            lowercase														=	"""eta""" in set(inspect.signature(self.scheduler.step						).parameters.keys()						)
            lowercase														=	{}
            if accepts_eta:
                  lowercase														=	eta

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

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

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

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

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

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

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

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

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

            if not return_dict:
                  return (image, None)

            return StableDiffusionPipelineOutput(images=__lowerCAmelCase		,       nsfw_content_detected=__lowerCAmelCase						)




"""simple docstring"""






from __future__ import annotations

from typing import Any





class  _A						:

      def __init__(						self		,       __lowerCAmelCase = 6						):







            """simple docstring"""



            lowercase														=	None
            lowercase														=	None
            self.create_linked_list(__lowerCAmelCase						)

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            lowercase														=	Node()
            lowercase														=	current_node
            lowercase														=	current_node
            lowercase														=	current_node
            for _ in range(1		,       __lowerCAmelCase						):
                  lowercase														=	Node()
                  lowercase														=	current_node
                  lowercase														=	previous_node
                  lowercase														=	current_node
            lowercase														=	self.front
            lowercase														=	previous_node

      def 				A__       (						self						):







            """simple docstring"""



            return (
                self.front == self.rear
                and self.front is not None
                and self.front.data is None
            )

      def 				A__       (						self						):







            """simple docstring"""



            self.check_can_perform_operation()
            return self.front.data if self.front else None

      def 				A__       (						self		,       __lowerCAmelCase						):







            """simple docstring"""



            if self.rear is None:
                  return

            self.check_is_full()
            if not self.is_empty():
                  lowercase														=	self.rear.next
            if self.rear:
                  lowercase														=	data

      def 				A__       (						self						):







            """simple docstring"""



            self.check_can_perform_operation()
            if self.rear is None or self.front is None:
                  return None
            if self.front == self.rear:
                  lowercase														=	self.front.data
                  lowercase														=	None
                  return data

            lowercase														=	self.front
            lowercase														=	old_front.next
            lowercase														=	old_front.data
            lowercase														=	None
            return data

      def 				A__       (						self						):







            """simple docstring"""



            if self.is_empty():
                  raise Exception("""Empty Queue"""						)







      def 				A__       (						self						):







            """simple docstring"""



            if self.rear and self.rear.next == self.front:
                  raise Exception("""Full Queue"""						)






class  _A						:

      def __init__(						self						):







            """simple docstring"""



            lowercase														=	None
            lowercase														=	None
            lowercase														=	None


if __name__ == "__main__":
       import doctest

       doctest.testmod()



