





"""simple docstring"""
import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device






def  A__    (      UpperCamelCase	):
       A		=  {}
       for name in unet.attn_processors.keys():
              A		=  None if name.endswith("attn1.processor"	) else unet.config.cross_attention_dim
              if name.startswith("mid_block"	):
                     A		=  unet.config.block_out_channels[-1]
              elif name.startswith("up_blocks"	):
                     A		=  int(name[len("up_blocks."	)]	)
                     A		=  list(reversed(unet.config.block_out_channels	)	)[block_id]
              elif name.startswith("down_blocks"	):
                     A		=  int(name[len("down_blocks."	)]	)
                     A		=  unet.config.block_out_channels[block_id]
              A		=  (
                  LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase ,  "scaled_dot_product_attention"	) else LoRAAttnProcessor
              )
              A		=  lora_attn_processor_class(
                  hidden_size=_lowerCAmelCase ,  cross_attention_dim=_lowerCAmelCase	)
       A		=  AttnProcsLayers(_lowerCAmelCase	)
       return lora_attn_procs, unet_lora_layers






def  A__    (      UpperCamelCase	):
       A		=  {}
       A		=  (
           LoRAAttnProcessor2_0 if hasattr(_lowerCAmelCase ,  "scaled_dot_product_attention"	) else LoRAAttnProcessor
       )
       for name, module in text_encoder.named_modules():
              if name.endswith(_lowerCAmelCase	):
                     A		=  lora_attn_processor_class(
                         hidden_size=module.out_proj.out_features ,  cross_attention_dim=_lowerCAmelCase	)
       return text_lora_attn_procs






def  A__    (      UpperCamelCase	):
       A		=  create_text_encoder_lora_attn_procs(_lowerCAmelCase	)
       A		=  AttnProcsLayers(_lowerCAmelCase	)
       return text_encoder_lora_layers






def  A__    (      UpperCamelCase ,  UpperCamelCase=False	):
       for _, attn_proc in text_lora_attn_procs.items():
              # set up.weights
              for layer_name, layer_module in attn_proc.named_modules():
                     if layer_name.endswith("_lora"	):
                            A		=  (
                                torch.randn_like(layer_module.up.weight	)
                                if randn_weight
                                else torch.zeros_like(layer_module.up.weight	)
                            )
                            A		=  torch.nn.Parameter(_lowerCAmelCase	)






class  _UpperCAmelCase       (     unittest.TestCase			):


     def      lowerCamelCase	( self      :str		):
            torch.manual_seed(0		)
            A		=  UNetaDConditionModel(
                block_out_channels=(32, 64)					,	layers_per_block=2					,	sample_size=32					,	in_channels=4					,	out_channels=4					,	down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")					,	up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")					,	cross_attention_dim=32					,	)
            A		=  DDIMScheduler(
                beta_start=0.00_085					,	beta_end=0.012					,	beta_schedule="scaled_linear"					,	clip_sample=__snake_case					,	set_alpha_to_one=__snake_case					,	steps_offset=1					,	)
            torch.manual_seed(0		)
            A		=  AutoencoderKL(
                block_out_channels=[32, 64]					,	in_channels=3					,	out_channels=3					,	down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]					,	up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]					,	latent_channels=4					,	)
            A		=  CLIPTextConfig(
                bos_token_id=0					,	eos_token_id=2					,	hidden_size=32					,	intermediate_size=37					,	layer_norm_eps=1e-05					,	num_attention_heads=4					,	num_hidden_layers=5					,	pad_token_id=1					,	vocab_size=10_00					,	)
            A		=  CLIPTextModel(__snake_case		)
            A		=  CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

            A		=  create_unet_lora_layers(__snake_case		)
            A		=  create_text_encoder_lora_layers(__snake_case		)

            A		=  {
                '''unet''': unet,
                '''scheduler''': scheduler,
                '''vae''': vae,
                '''text_encoder''': text_encoder,
                '''tokenizer''': tokenizer,
                '''safety_checker''': None,
                '''feature_extractor''': None,
            }
            A		=  {
                '''unet_lora_layers''': unet_lora_layers,
                '''text_encoder_lora_layers''': text_encoder_lora_layers,
                '''unet_lora_attn_procs''': unet_lora_attn_procs,
            }
            return pipeline_components, lora_components


     def      lowerCamelCase	( self      :Union[str, Any]		):
            A		=  1
            A		=  10
            A		=  4
            A		=  (32, 32)

            A		=  torch.manual_seed(0		)
            A		=  floats_tensor((batch_size, num_channels) + sizes		)
            A		=  torch.randint(1					,	__snake_case					,	size=(batch_size, sequence_length)					,	generator=__snake_case		)

            A		=  {
                '''prompt''': '''A painting of a squirrel eating a burger''',
                '''generator''': generator,
                '''num_inference_steps''': 2,
                '''guidance_scale''': 6.0,
                '''output_type''': '''numpy''',
            }

            return noise, input_ids, pipeline_inputs

            # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb


     def      lowerCamelCase	( self      :str		):
            A		=  77

            A		=  torch.randint(2					,	56					,	size=(1, max_seq_length)					,	generator=torch.manual_seed(0		)		)

            A		=  {}
            A		=  inputs
            return prepared_inputs


     def      lowerCamelCase	( self      :Any					,	__UpperCamelCase      :Dict		):
            A		=  self.get_dummy_components()
            LoraLoaderMixin.save_lora_weights(
                save_directory=__snake_case					,	unet_lora_layers=lora_components["unet_lora_layers"]					,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]					,	)
            self.assertTrue(os.path.isfile(os.path.join(__snake_case					,	"pytorch_lora_weights.bin"		)		)		)


     def      lowerCamelCase	( self      :List[str]		):
            A		=  self.get_dummy_components()
            A		=  StableDiffusionPipeline(**__snake_case		)
            A		=  sd_pipe.to(__snake_case		)
            sd_pipe.set_progress_bar_config(disable=__snake_case		)

            A		=  self.get_dummy_inputs()

            A		=  sd_pipe(**__snake_case		).images
            A		=  original_images[0, -3:, -3:, -1]

            with tempfile.TemporaryDirectory() as tmpdirname:
                   LoraLoaderMixin.save_lora_weights(
                       save_directory=__snake_case					,	unet_lora_layers=lora_components["unet_lora_layers"]					,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]					,	)
                   self.assertTrue(os.path.isfile(os.path.join(__snake_case					,	"pytorch_lora_weights.bin"		)		)		)
                   sd_pipe.load_lora_weights(__snake_case		)

            A		=  sd_pipe(**__snake_case		).images
            A		=  lora_images[0, -3:, -3:, -1]

            # Outputs shouldn't match.
            self.assertFalse(torch.allclose(torch.from_numpy(__snake_case		)					,	torch.from_numpy(__snake_case		)		)		)


     def      lowerCamelCase	( self      :Any		):
            A		=  self.get_dummy_components()
            A		=  StableDiffusionPipeline(**__snake_case		)
            A		=  sd_pipe.to(__snake_case		)
            sd_pipe.set_progress_bar_config(disable=__snake_case		)

            A		=  self.get_dummy_inputs()

            A		=  sd_pipe(**__snake_case		).images
            A		=  original_images[0, -3:, -3:, -1]

            with tempfile.TemporaryDirectory() as tmpdirname:
                   LoraLoaderMixin.save_lora_weights(
                       save_directory=__snake_case					,	unet_lora_layers=lora_components["unet_lora_layers"]					,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]					,	safe_serialization=__snake_case					,	)
                   self.assertTrue(os.path.isfile(os.path.join(__snake_case					,	"pytorch_lora_weights.safetensors"		)		)		)
                   sd_pipe.load_lora_weights(__snake_case		)

            A		=  sd_pipe(**__snake_case		).images
            A		=  lora_images[0, -3:, -3:, -1]

            # Outputs shouldn't match.
            self.assertFalse(torch.allclose(torch.from_numpy(__snake_case		)					,	torch.from_numpy(__snake_case		)		)		)


     def      lowerCamelCase	( self      :List[str]		):
            A		=  self.get_dummy_components()
            A		=  lora_components['''unet_lora_attn_procs''']
            A		=  StableDiffusionPipeline(**__snake_case		)
            A		=  sd_pipe.to(__snake_case		)
            sd_pipe.set_progress_bar_config(disable=__snake_case		)

            A		=  self.get_dummy_inputs()

            A		=  sd_pipe(**__snake_case		).images
            A		=  original_images[0, -3:, -3:, -1]

            with tempfile.TemporaryDirectory() as tmpdirname:
                   A		=  sd_pipe.unet
                   unet.set_attn_processor(__snake_case		)
                   unet.save_attn_procs(__snake_case		)
                   self.assertTrue(os.path.isfile(os.path.join(__snake_case					,	"pytorch_lora_weights.bin"		)		)		)
                   sd_pipe.load_lora_weights(__snake_case		)

            A		=  sd_pipe(**__snake_case		).images
            A		=  lora_images[0, -3:, -3:, -1]

            # Outputs shouldn't match.
            self.assertFalse(torch.allclose(torch.from_numpy(__snake_case		)					,	torch.from_numpy(__snake_case		)		)		)


     def      lowerCamelCase	( self      :Optional[int]		):
            A		=  self.get_dummy_components()
            A		=  StableDiffusionPipeline(**__snake_case		)

            A		=  self.get_dummy_tokens()

            # inference without lora
            A		=  pipe.text_encoder(**__snake_case		)[0]
            assert outputs_without_lora.shape == (1, 77, 32)

            # create lora_attn_procs with zeroed out up.weights
            A		=  create_text_encoder_lora_attn_procs(pipe.text_encoder		)
            set_lora_up_weights(__snake_case					,	randn_weight=__snake_case		)

            # monkey patch
            pipe._modify_text_encoder(__snake_case		)

            # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
            del text_attn_procs
            gc.collect()

            # inference with lora
            A		=  pipe.text_encoder(**__snake_case		)[0]
            assert outputs_with_lora.shape == (1, 77, 32)

            assert torch.allclose(
                __snake_case					,	__snake_case		), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

            # create lora_attn_procs with randn up.weights
            A		=  create_text_encoder_lora_attn_procs(pipe.text_encoder		)
            set_lora_up_weights(__snake_case					,	randn_weight=__snake_case		)

            # monkey patch
            pipe._modify_text_encoder(__snake_case		)

            # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
            del text_attn_procs
            gc.collect()

            # inference with lora
            A		=  pipe.text_encoder(**__snake_case		)[0]
            assert outputs_with_lora.shape == (1, 77, 32)

            assert not torch.allclose(
                __snake_case					,	__snake_case		), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"


     def      lowerCamelCase	( self      :Optional[int]		):
            A		=  self.get_dummy_components()
            A		=  StableDiffusionPipeline(**__snake_case		)

            A		=  self.get_dummy_tokens()

            # inference without lora
            A		=  pipe.text_encoder(**__snake_case		)[0]
            assert outputs_without_lora.shape == (1, 77, 32)

            # create lora_attn_procs with randn up.weights
            A		=  create_text_encoder_lora_attn_procs(pipe.text_encoder		)
            set_lora_up_weights(__snake_case					,	randn_weight=__snake_case		)

            # monkey patch
            pipe._modify_text_encoder(__snake_case		)

            # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
            del text_attn_procs
            gc.collect()

            # inference with lora
            A		=  pipe.text_encoder(**__snake_case		)[0]
            assert outputs_with_lora.shape == (1, 77, 32)

            assert not torch.allclose(
                __snake_case					,	__snake_case		), "lora outputs should be different to without lora outputs"

            # remove monkey patch
            pipe._remove_text_encoder_monkey_patch()

            # inference with removed lora
            A		=  pipe.text_encoder(**__snake_case		)[0]
            assert outputs_without_lora_removed.shape == (1, 77, 32)

            assert torch.allclose(
                __snake_case					,	__snake_case		), "remove lora monkey patch should restore the original outputs"


     def      lowerCamelCase	( self      :str		):
            A		=  self.get_dummy_components()
            A		=  StableDiffusionPipeline(**__snake_case		)
            A		=  sd_pipe.to(__snake_case		)
            sd_pipe.set_progress_bar_config(disable=__snake_case		)

            A		=  self.get_dummy_inputs()

            with tempfile.TemporaryDirectory() as tmpdirname:
                   LoraLoaderMixin.save_lora_weights(
                       save_directory=__snake_case					,	unet_lora_layers=lora_components["unet_lora_layers"]					,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]					,	)
                   self.assertTrue(os.path.isfile(os.path.join(__snake_case					,	"pytorch_lora_weights.bin"		)		)		)
                   sd_pipe.load_lora_weights(__snake_case		)

            A		=  sd_pipe(**__snake_case		).images
            A		=  lora_images[0, -3:, -3:, -1]

            A		=  sd_pipe(**__snake_case					,	cross_attention_kwargs={"scale": 0.5}		).images
            A		=  lora_images_with_scale[0, -3:, -3:, -1]

            # Outputs shouldn't match.
            self.assertFalse(
                torch.allclose(torch.from_numpy(__snake_case		)					,	torch.from_numpy(__snake_case		)		)		)


     def      lowerCamelCase	( self      :Tuple		):
            with tempfile.TemporaryDirectory() as tmpdirname:
                   self.create_lora_weight_file(__snake_case		)

                   A		=  self.get_dummy_components()
                   A		=  StableDiffusionPipeline(**__snake_case		)
                   A		=  sd_pipe.to(__snake_case		)
                   sd_pipe.set_progress_bar_config(disable=__snake_case		)

                   # check if vanilla attention processors are used
                   for _, module in sd_pipe.unet.named_modules():
                          if isinstance(__snake_case					,	__snake_case		):
                                 self.assertIsInstance(module.processor					,	(AttnProcessor, AttnProcessor2_0)		)

            # load LoRA weight file
                   sd_pipe.load_lora_weights(__snake_case		)

                   # check if lora attention processors are used
                   for _, module in sd_pipe.unet.named_modules():
                          if isinstance(__snake_case					,	__snake_case		):
                                 A		=  (
                                     LoRAAttnProcessor2_0 if hasattr(__snake_case					,	"scaled_dot_product_attention"		) else LoRAAttnProcessor
                                 )
                                 self.assertIsInstance(module.processor					,	__snake_case		)


     @unittest.skipIf(torch_device != "cuda"					,	"This test is supposed to run on GPU"		)
     def      lowerCamelCase	( self      :List[str]		):
            with tempfile.TemporaryDirectory() as tmpdirname:
                   self.create_lora_weight_file(__snake_case		)

                   A		=  self.get_dummy_components()
                   A		=  StableDiffusionPipeline(**__snake_case		)
                   A		=  sd_pipe.to(__snake_case		)
                   sd_pipe.set_progress_bar_config(disable=__snake_case		)

                   # enable XFormers
                   sd_pipe.enable_xformers_memory_efficient_attention()

                   # check if xFormers attention processors are used
                   for _, module in sd_pipe.unet.named_modules():
                          if isinstance(__snake_case					,	__snake_case		):
                                 self.assertIsInstance(module.processor					,	__snake_case		)

            # load LoRA weight file
                   sd_pipe.load_lora_weights(__snake_case		)

                   # check if lora attention processors are used
                   for _, module in sd_pipe.unet.named_modules():
                          if isinstance(__snake_case					,	__snake_case		):
                                 self.assertIsInstance(module.processor					,	__snake_case		)


     @unittest.skipIf(torch_device != "cuda"					,	"This test is supposed to run on GPU"		)
     def      lowerCamelCase	( self      :List[Any]		):
            A		=  self.get_dummy_components()
            A		=  StableDiffusionPipeline(**__snake_case		)
            A		=  sd_pipe.to(__snake_case		)
            sd_pipe.set_progress_bar_config(disable=__snake_case		)

            A		=  self.get_dummy_inputs()

            # enable XFormers
            sd_pipe.enable_xformers_memory_efficient_attention()

            A		=  sd_pipe(**__snake_case		).images
            A		=  original_images[0, -3:, -3:, -1]

            with tempfile.TemporaryDirectory() as tmpdirname:
                   LoraLoaderMixin.save_lora_weights(
                       save_directory=__snake_case					,	unet_lora_layers=lora_components["unet_lora_layers"]					,	text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]					,	)
                   self.assertTrue(os.path.isfile(os.path.join(__snake_case					,	"pytorch_lora_weights.bin"		)		)		)
                   sd_pipe.load_lora_weights(__snake_case		)

            A		=  sd_pipe(**__snake_case		).images
            A		=  lora_images[0, -3:, -3:, -1]

            # Outputs shouldn't match.
            self.assertFalse(torch.allclose(torch.from_numpy(__snake_case		)					,	torch.from_numpy(__snake_case		)		)		)









"""simple docstring"""
import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType






class  _UpperCAmelCase       (     lowercase_			):
					UpperCamelCase								=							['''image_processor''', '''tokenizer''']
					UpperCamelCase								=							'''LayoutLMv2ImageProcessor'''
					UpperCamelCase								=							('''LayoutLMv2Tokenizer''', '''LayoutLMv2TokenizerFast''')


					def __init__( self      :List[Any]					,	__UpperCamelCase      :List[Any]=None					,	__UpperCamelCase      :Tuple=None					,	**__UpperCamelCase      :int		):
												A		=  None
												if "feature_extractor" in kwargs:
																			warnings.warn(
																			    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
																			    " instead."					,	__UpperCamelCase					,	)
																			A		=  kwargs.pop("feature_extractor"		)

												A		=  image_processor if image_processor is not None else feature_extractor
												if image_processor is None:
																			raise ValueError("You need to specify an `image_processor`."		)
												if tokenizer is None:
																			raise ValueError("You need to specify a `tokenizer`."		)

												super().__init__(__UpperCamelCase					,	__UpperCamelCase		)


					def __call__( self      :Optional[Any]					,	__UpperCamelCase      :int					,	__UpperCamelCase      :Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None					,	__UpperCamelCase      :Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None					,	__UpperCamelCase      :Union[List[List[int]], List[List[List[int]]]] = None					,	__UpperCamelCase      :Optional[Union[List[int], List[List[int]]]] = None					,	__UpperCamelCase      :bool = True					,	__UpperCamelCase      :Union[bool, str, PaddingStrategy] = False					,	__UpperCamelCase      :Union[bool, str, TruncationStrategy] = False					,	__UpperCamelCase      :Optional[int] = None					,	__UpperCamelCase      :int = 0					,	__UpperCamelCase      :Optional[int] = None					,	__UpperCamelCase      :Optional[bool] = None					,	__UpperCamelCase      :Optional[bool] = None					,	__UpperCamelCase      :bool = False					,	__UpperCamelCase      :bool = False					,	__UpperCamelCase      :bool = False					,	__UpperCamelCase      :bool = False					,	__UpperCamelCase      :bool = True					,	__UpperCamelCase      :Optional[Union[str, TensorType]] = None					,	**__UpperCamelCase      :int					,	):
												# verify input
												if self.image_processor.apply_ocr and (boxes is not None):
																			raise ValueError(
																			    "You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True."		)

												if self.image_processor.apply_ocr and (word_labels is not None):
																			raise ValueError(
																			    "You cannot provide word labels if you initialized the image processor with apply_ocr set to True."		)

												if return_overflowing_tokens is True and return_offsets_mapping is False:
																			raise ValueError("You cannot return overflowing tokens without returning the offsets mapping."		)

												# first, apply the image processor
												A		=  self.image_processor(images=__UpperCamelCase					,	return_tensors=__UpperCamelCase		)

												# second, apply the tokenizer
												if text is not None and self.image_processor.apply_ocr and text_pair is None:
																			if isinstance(__UpperCamelCase					,	__UpperCamelCase		):
																										A		=  [text]  # add batch dimension (as the image processor always adds a batch dimension)
																			A		=  features["words"]

												A		=  self.tokenizer(
												    text=text if text is not None else features["words"]					,	text_pair=text_pair if text_pair is not None else None					,	boxes=boxes if boxes is not None else features["boxes"]					,	word_labels=__UpperCamelCase					,	add_special_tokens=__UpperCamelCase					,	padding=__UpperCamelCase					,	truncation=__UpperCamelCase					,	max_length=__UpperCamelCase					,	stride=__UpperCamelCase					,	pad_to_multiple_of=__UpperCamelCase					,	return_token_type_ids=__UpperCamelCase					,	return_attention_mask=__UpperCamelCase					,	return_overflowing_tokens=__UpperCamelCase					,	return_special_tokens_mask=__UpperCamelCase					,	return_offsets_mapping=__UpperCamelCase					,	return_length=__UpperCamelCase					,	verbose=__UpperCamelCase					,	return_tensors=__UpperCamelCase					,	**__UpperCamelCase					,	)

												# add pixel values
												A		=  features.pop("pixel_values"		)
												if return_overflowing_tokens is True:
																			A		=  self.get_overflowing_images(__UpperCamelCase					,	encoded_inputs["overflow_to_sample_mapping"]		)
												A		=  images

												return encoded_inputs


					def      lowerCamelCase	( self      :Union[str, Any]					,	__UpperCamelCase      :List[str]					,	__UpperCamelCase      :List[str]		):
												# in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
												A		=  []
												for sample_idx in overflow_to_sample_mapping:
																			images_with_overflow.append(images[sample_idx]		)

												if len(__UpperCamelCase		) != len(__UpperCamelCase		):
																			raise ValueError(
																			    "Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got"
																			    f" {len(__UpperCamelCase		)} and {len(__UpperCamelCase		)}"		)

												return images_with_overflow


					def      lowerCamelCase	( self      :Tuple					,	*__UpperCamelCase      :Union[str, Any]					,	**__UpperCamelCase      :Tuple		):
												return self.tokenizer.batch_decode(*__UpperCamelCase					,	**__UpperCamelCase		)


					def      lowerCamelCase	( self      :Union[str, Any]					,	*__UpperCamelCase      :str					,	**__UpperCamelCase      :List[str]		):
												return self.tokenizer.decode(*__UpperCamelCase					,	**__UpperCamelCase		)


					@property
					def      lowerCamelCase	( self      :str		):
												return ["input_ids", "bbox", "token_type_ids", "attention_mask", "image"]


					@property
					def      lowerCamelCase	( self      :str		):
												warnings.warn(
												    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."					,	__UpperCamelCase					,	)
												return self.image_processor_class


					@property
					def      lowerCamelCase	( self      :int		):
												warnings.warn(
												    "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."					,	__UpperCamelCase					,	)
												return self.image_processor


