





import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


_UpperCAmelCase       : Union[str, Any]           =       get_logger(__name__)


_UpperCAmelCase       : Dict           =       Path(__file__).parent / """model_card_template.md"""
_UpperCAmelCase       : Optional[Any]           =       uuida().hex
_UpperCAmelCase       : str           =       os.getenv("""HF_HUB_OFFLINE""", """""").upper() in ENV_VARS_TRUE_VALUES
_UpperCAmelCase       : Optional[int]           =       os.getenv("""DISABLE_TELEMETRY""", """""").upper() in ENV_VARS_TRUE_VALUES
_UpperCAmelCase       : Tuple           =       HUGGINGFACE_CO_RESOLVE_ENDPOINT + """/api/telemetry/"""


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase = None				)    ->  str:
    lowerCamelCase__					:   Optional[Any]      				=	F"""diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}"""
    if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
        return ua + "; telemetry/off"
    if is_torch_available():
        ua += F"""; torch/{_torch_version}"""
    if is_flax_available():
        ua += F"""; jax/{_jax_version}"""
        ua += F"""; flax/{_flax_version}"""
    if is_onnx_available():
        ua += F"""; onnxruntime/{_onnxruntime_version}"""
    # CI will set this value to True
    if os.environ.get('DIFFUSERS_IS_CI'		,			''				).upper() in ENV_VARS_TRUE_VALUES:
        ua += "; is_ci/true"
    if isinstance(__UpperCamelCase		,			__UpperCamelCase				):
        ua += "; " + "; ".join(F"""{k}/{v}""" for k, v in user_agent.items()				)
    elif isinstance(__UpperCamelCase		,			__UpperCamelCase				):
        ua += "; " + user_agent
    return ua


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase = None		,			_UpperCAmelCase = None				)    ->  Optional[int]:
    if token is None:
        lowerCamelCase__					:   Tuple      				=	HfFolder.get_token()
    if organization is None:
        lowerCamelCase__					:   List[Any]      				=	whoami(__UpperCamelCase				)['name']
        return F"""{username}/{model_id}"""
    else:
        return F"""{organization}/{model_id}"""


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase				)    ->  Dict:
    if not is_jinja_available():
        raise ValueError(
            'Modelcard rendering is based on Jinja templates.'
            ' Please make sure to have `jinja` installed before using `create_model_card`.'
            ' To install it, please run `pip install Jinja2`.'				)

    if hasattr(__UpperCamelCase		,			'local_rank'				) and args.local_rank not in [-1, 0]:
        return

    lowerCamelCase__					:   Union[str, Any]      				=	args.hub_token if hasattr(__UpperCamelCase		,			'hub_token'				) else None
    lowerCamelCase__					:   Any      				=	get_full_repo_name(__UpperCamelCase		,			token=__UpperCamelCase				)

    lowerCamelCase__					:   List[Any]      				=	ModelCard.from_template(
        card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
            language='en'		,			license='apache-2.0'		,			library_name='diffusers'		,			tags=[]		,			datasets=args.dataset_name		,			metrics=[]		,			)		,			template_path=__UpperCamelCase		,			model_name=__UpperCamelCase		,			repo_name=__UpperCamelCase		,			dataset_name=args.dataset_name if hasattr(__UpperCamelCase		,			'dataset_name'				) else None		,			learning_rate=args.learning_rate		,			train_batch_size=args.train_batch_size		,			eval_batch_size=args.eval_batch_size		,			gradient_accumulation_steps=(
            args.gradient_accumulation_steps if hasattr(__UpperCamelCase		,			'gradient_accumulation_steps'				) else None
        )		,			adam_betaa=args.adam_betaa if hasattr(__UpperCamelCase		,			'adam_beta1'				) else None		,			adam_betaa=args.adam_betaa if hasattr(__UpperCamelCase		,			'adam_beta2'				) else None		,			adam_weight_decay=args.adam_weight_decay if hasattr(__UpperCamelCase		,			'adam_weight_decay'				) else None		,			adam_epsilon=args.adam_epsilon if hasattr(__UpperCamelCase		,			'adam_epsilon'				) else None		,			lr_scheduler=args.lr_scheduler if hasattr(__UpperCamelCase		,			'lr_scheduler'				) else None		,			lr_warmup_steps=args.lr_warmup_steps if hasattr(__UpperCamelCase		,			'lr_warmup_steps'				) else None		,			ema_inv_gamma=args.ema_inv_gamma if hasattr(__UpperCamelCase		,			'ema_inv_gamma'				) else None		,			ema_power=args.ema_power if hasattr(__UpperCamelCase		,			'ema_power'				) else None		,			ema_max_decay=args.ema_max_decay if hasattr(__UpperCamelCase		,			'ema_max_decay'				) else None		,			mixed_precision=args.mixed_precision		,			)

    lowerCamelCase__					:   Tuple      				=	os.path.join(args.output_dir		,			'README.md'				)
    model_card.save(__UpperCamelCase				)


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase = None				)    ->  Optional[int]:
    if resolved_file is None or commit_hash is not None:
        return commit_hash
    lowerCamelCase__					:   str      				=	str(Path(__UpperCamelCase				).as_posix()				)
    lowerCamelCase__					:   str      				=	re.search(r'snapshots/([^/]+)/'		,			__UpperCamelCase				)
    if search is None:
        return None
    lowerCamelCase__					:   List[Any]      				=	search.groups()[0]
    return commit_hash if REGEX_COMMIT_HASH.match(__UpperCamelCase				) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
_UpperCAmelCase       : Any           =       os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
_UpperCAmelCase       : int           =       os.path.join(hf_cache_home, """diffusers""")


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase = None		,			_UpperCAmelCase = None				)    ->  None:
    if new_cache_dir is None:
        lowerCamelCase__					:   Optional[int]      				=	DIFFUSERS_CACHE
    if old_cache_dir is None:
        lowerCamelCase__					:   Union[str, Any]      				=	old_diffusers_cache

    lowerCamelCase__					:   int      				=	Path(__UpperCamelCase				).expanduser()
    lowerCamelCase__					:   Union[str, Any]      				=	Path(__UpperCamelCase				).expanduser()
    for old_blob_path in old_cache_dir.glob('**/blobs/*'				):
        if old_blob_path.is_file() and not old_blob_path.is_symlink():
            lowerCamelCase__					:   str      				=	new_cache_dir / old_blob_path.relative_to(__UpperCamelCase				)
            new_blob_path.parent.mkdir(parents=__UpperCamelCase		,			exist_ok=__UpperCamelCase				)
            os.replace(__UpperCamelCase		,			__UpperCamelCase				)
            try:
                os.symlink(__UpperCamelCase		,			__UpperCamelCase				)
            except OSError:
                logger.warning(
                    'Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded.'				)
    # At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


_UpperCAmelCase       : Union[str, Any]           =       os.path.join(DIFFUSERS_CACHE, """version_diffusers_cache.txt""")
if not os.path.isfile(cache_version_file):
    _UpperCAmelCase       : Any           =       0
else:
    with open(cache_version_file) as f:
        try:
            _UpperCAmelCase       : Union[str, Any]           =       int(f.read())
        except ValueError:
            _UpperCAmelCase       : Optional[int]           =       0

if cache_version < 1:
    _UpperCAmelCase       : str           =       os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
    if old_cache_is_not_empty:
        logger.warning(
            """The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your """
            """existing cached models. This is a one-time operation, you can interrupt it or run it """
            """later by calling `diffusers.utils.hub_utils.move_cache()`."""
        )
        try:
            move_cache()
        except Exception as e:
            _UpperCAmelCase       : Optional[Any]           =       """\n""".join(traceback.format_tb(e.__traceback__))
            logger.error(
                F"""There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease """
                """file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole """
                """message and we will do our best to help."""
            )

if cache_version < 1:
    try:
        os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
        with open(cache_version_file, """w""") as f:
            f.write("""1""")
    except Exception:
        logger.warning(
            F"""There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure """
            """the directory exists and can be written to."""
        )


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			_UpperCAmelCase = None				)    ->  str:
    if variant is not None:
        lowerCamelCase__					:   str      				=	weights_name.split('.'				)
        lowerCamelCase__					:   int      				=	splits[:-1] + [variant] + splits[-1:]
        lowerCamelCase__					:   Optional[int]      				=	'.'.join(__UpperCamelCase				)

    return weights_name


def  SCREAMING_SNAKE_CASE   ( _UpperCAmelCase		,			*,
    _UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase		,			_UpperCAmelCase=None		,			)    ->  str:
    lowerCamelCase__					:   str      				=	str(__UpperCamelCase				)
    if os.path.isfile(__UpperCamelCase				):
        return pretrained_model_name_or_path
    elif os.path.isdir(__UpperCamelCase				):
        if os.path.isfile(os.path.join(__UpperCamelCase		,			__UpperCamelCase				)				):
            # Load from a PyTorch checkpoint
            lowerCamelCase__					:   List[Any]      				=	os.path.join(__UpperCamelCase		,			__UpperCamelCase				)
            return model_file
        elif subfolder is not None and os.path.isfile(
            os.path.join(__UpperCamelCase		,			__UpperCamelCase		,			__UpperCamelCase				)				):
            lowerCamelCase__					:   Optional[int]      				=	os.path.join(__UpperCamelCase		,			__UpperCamelCase		,			__UpperCamelCase				)
            return model_file
        else:
            raise EnvironmentError(
                F"""Error no file named {weights_name} found in directory {pretrained_model_name_or_path}."""				)
    else:
        # 1. First check if deprecated way of loading from branches is used
        if (
            revision in DEPRECATED_REVISION_ARGS
            and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
            and version.parse(version.parse(__UpperCamelCase				).base_version				) >= version.parse('0.20.0'				)
        ):
            try:
                lowerCamelCase__					:   str      				=	hf_hub_download(
                    __UpperCamelCase		,			filename=_add_variant(__UpperCamelCase		,			__UpperCamelCase				)		,			cache_dir=__UpperCamelCase		,			force_download=__UpperCamelCase		,			proxies=__UpperCamelCase		,			resume_download=__UpperCamelCase		,			local_files_only=__UpperCamelCase		,			use_auth_token=__UpperCamelCase		,			user_agent=__UpperCamelCase		,			subfolder=__UpperCamelCase		,			revision=revision or commit_hash		,			)
                warnings.warn(
                    F"""Loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'` is deprecated. Loading instead from `revision=\'main\'` with `variant={revision}`. Loading model variants via `revision=\'{revision}\'` will be removed in diffusers v1. Please use `variant=\'{revision}\'` instead."""		,			__UpperCamelCase		,			)
                return model_file
            except:  # noqa: E722
                warnings.warn(
                    F"""You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant=\'{revision}\'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(__UpperCamelCase		,			__UpperCamelCase				)} file in the \'main\' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title \'{pretrained_model_name_or_path} is missing {_add_variant(__UpperCamelCase		,			__UpperCamelCase				)}\' so that the correct variant file can be added."""		,			__UpperCamelCase		,			)
        try:
            # 2. Load model file as usual
            lowerCamelCase__					:   Optional[Any]      				=	hf_hub_download(
                __UpperCamelCase		,			filename=__UpperCamelCase		,			cache_dir=__UpperCamelCase		,			force_download=__UpperCamelCase		,			proxies=__UpperCamelCase		,			resume_download=__UpperCamelCase		,			local_files_only=__UpperCamelCase		,			use_auth_token=__UpperCamelCase		,			user_agent=__UpperCamelCase		,			subfolder=__UpperCamelCase		,			revision=revision or commit_hash		,			)
            return model_file

        except RepositoryNotFoundError:
            raise EnvironmentError(
                F"""{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier """
                'listed on \'https://huggingface.co/models\'\nIf this is a private repository, make sure to pass a '
                'token having permission to this repo with `use_auth_token` or log in with `huggingface-cli '
                'login`.'				)
        except RevisionNotFoundError:
            raise EnvironmentError(
                F"""{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for """
                'this model name. Check the model page at '
                F"""\'https://huggingface.co/{pretrained_model_name_or_path}\' for available revisions."""				)
        except EntryNotFoundError:
            raise EnvironmentError(
                F"""{pretrained_model_name_or_path} does not appear to have a file named {weights_name}."""				)
        except HTTPError as err:
            raise EnvironmentError(
                F"""There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}"""				)
        except ValueError:
            raise EnvironmentError(
                F"""We couldn\'t connect to \'{HUGGINGFACE_CO_RESOLVE_ENDPOINT}\' to load this model, couldn\'t find it"""
                F""" in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a"""
                F""" directory containing a file named {weights_name} or"""
                ' \nCheckout your internet connection or see how to run the library in'
                ' offline mode at \'https://huggingface.co/docs/diffusers/installation#offline-mode\'.'				)
        except EnvironmentError:
            raise EnvironmentError(
                F"""Can\'t load the model for \'{pretrained_model_name_or_path}\'. If you were trying to load it from """
                '\'https://huggingface.co/models\', make sure you don\'t have a local directory with the same name. '
                F"""Otherwise, make sure \'{pretrained_model_name_or_path}\' is the correct path to a directory """
                F"""containing a file named {weights_name}"""				)












import warnings
from typing import List

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import is_flax_available, is_tf_available, is_torch_available

class      lowerCAmelCase							(      __UpperCamelCase    ):
 UpperCAmelCase__									=	["""image_processor""", """tokenizer"""]
 UpperCAmelCase__									=	"""OwlViTImageProcessor"""
 UpperCAmelCase__									=	("""CLIPTokenizer""", """CLIPTokenizerFast""")
 def __init__(   self						:   Optional[int]    ,  UpperCAmelCase						:   str=None    ,  UpperCAmelCase						:   Any=None    ,  **UpperCAmelCase						:   Optional[Any]			)    ->			Dict:
     lowerCamelCase__					:   Any      				=	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    ,  )
         lowerCamelCase__					:   Optional[Any]      				=	kwargs.pop('feature_extractor'			)

     lowerCamelCase__					:   Dict      				=	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						:   List[Any]    ,  UpperCAmelCase						:   List[Any]=None    ,  UpperCAmelCase						:   Tuple=None    ,  UpperCAmelCase						:   int=None    ,  UpperCAmelCase						:   Optional[int]="max_length"    ,  UpperCAmelCase						:   Dict="np"    ,  **UpperCAmelCase						:   Union[str, Any]			)    ->			Union[str, Any]:

     if text is None and query_images is None and images is None:
         raise ValueError(
             'You have to specify at least one text or query image or image. All three cannot be none.'			)

     if text is not None:
         if isinstance(UpperCAmelCase    ,  UpperCAmelCase			) or (isinstance(UpperCAmelCase    ,  UpperCAmelCase			) and not isinstance(text[0]    ,  UpperCAmelCase			)):
             lowerCamelCase__					:   Any      				=	[self.tokenizer(UpperCAmelCase    ,  padding=UpperCAmelCase    ,  return_tensors=UpperCAmelCase    ,  **UpperCAmelCase			)]

         elif isinstance(UpperCAmelCase    ,  UpperCAmelCase			) and isinstance(text[0]    ,  UpperCAmelCase			):
             lowerCamelCase__					:   List[str]      				=	[]

             # Maximum number of queries across batch
             lowerCamelCase__					:   List[Any]      				=	max([len(UpperCAmelCase			) for t in text]			)

             # Pad all batch samples to max number of text queries
             for t in text:
                 if len(UpperCAmelCase			) != max_num_queries:
                     lowerCamelCase__					:   int      				=	t + [' '] * (max_num_queries - len(UpperCAmelCase			))

                 lowerCamelCase__					:   str      				=	self.tokenizer(UpperCAmelCase    ,  padding=UpperCAmelCase    ,  return_tensors=UpperCAmelCase    ,  **UpperCAmelCase			)
                 encodings.append(UpperCAmelCase			)
         else:
             raise TypeError('Input text should be a string, a list of strings or a nested list of strings'			)

         if return_tensors == "np":
             lowerCamelCase__					:   Optional[Any]      				=	np.concatenate([encoding['input_ids'] for encoding in encodings]    ,  axis=0			)
             lowerCamelCase__					:   int      				=	np.concatenate([encoding['attention_mask'] for encoding in encodings]    ,  axis=0			)

         elif return_tensors == "jax" and is_flax_available():
             import jax.numpy as jnp

             lowerCamelCase__					:   Optional[int]      				=	jnp.concatenate([encoding['input_ids'] for encoding in encodings]    ,  axis=0			)
             lowerCamelCase__					:   Any      				=	jnp.concatenate([encoding['attention_mask'] for encoding in encodings]    ,  axis=0			)

         elif return_tensors == "pt" and is_torch_available():
             import torch

             lowerCamelCase__					:   Union[str, Any]      				=	torch.cat([encoding['input_ids'] for encoding in encodings]    ,  dim=0			)
             lowerCamelCase__					:   Dict      				=	torch.cat([encoding['attention_mask'] for encoding in encodings]    ,  dim=0			)

         elif return_tensors == "tf" and is_tf_available():
             import tensorflow as tf

             lowerCamelCase__					:   Any      				=	tf.stack([encoding['input_ids'] for encoding in encodings]    ,  axis=0			)
             lowerCamelCase__					:   Optional[int]      				=	tf.stack([encoding['attention_mask'] for encoding in encodings]    ,  axis=0			)

         else:
             raise ValueError('Target return tensor type could not be returned'			)

         lowerCamelCase__					:   str      				=	BatchEncoding()
         lowerCamelCase__					:   int      				=	input_ids
         lowerCamelCase__					:   Any      				=	attention_mask

     if query_images is not None:
         lowerCamelCase__					:   Union[str, Any]      				=	BatchEncoding()
         lowerCamelCase__					:   Optional[Any]      				=	self.image_processor(
             UpperCAmelCase    ,  return_tensors=UpperCAmelCase    ,  **UpperCAmelCase			).pixel_values
         lowerCamelCase__					:   List[Any]      				=	query_pixel_values

     if images is not None:
         lowerCamelCase__					:   List[Any]      				=	self.image_processor(UpperCAmelCase    ,  return_tensors=UpperCAmelCase    ,  **UpperCAmelCase			)

     if text is not None and images is not None:
         lowerCamelCase__					:   Tuple      				=	image_features.pixel_values
         return encoding
     elif query_images is not None and images is not None:
         lowerCamelCase__					:   Dict      				=	image_features.pixel_values
         return encoding
     elif text is not None or query_images is not None:
         return encoding
     else:
         return BatchEncoding(data=dict(**UpperCAmelCase			)    ,  tensor_type=UpperCAmelCase			)
 def   A_			(   self						:   str    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   List[Any]			)    ->			Any:
     return self.image_processor.post_process(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   int    ,  *UpperCAmelCase						:   List[Any]    ,  **UpperCAmelCase						:   Tuple			)    ->			str:
     return self.image_processor.post_process_object_detection(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   Tuple    ,  *UpperCAmelCase						:   Dict    ,  **UpperCAmelCase						:   Optional[int]			)    ->			Optional[Any]:
     return self.image_processor.post_process_image_guided_detection(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   Optional[Any]    ,  *UpperCAmelCase						:   Tuple    ,  **UpperCAmelCase						:   List[Any]			)    ->			Tuple:
     return self.tokenizer.batch_decode(*UpperCAmelCase    ,  **UpperCAmelCase			)
 def   A_			(   self						:   Union[str, Any]    ,  *UpperCAmelCase						:   List[Any]    ,  **UpperCAmelCase						:   List[Any]			)    ->			List[str]:
     return self.tokenizer.decode(*UpperCAmelCase    ,  **UpperCAmelCase			)
 @property
 def   A_			(   self						:   List[str]			)    ->			Optional[Any]:
     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   A_			(   self						:   int			)    ->			int:
     warnings.warn(
         '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'    ,  UpperCAmelCase    ,  )
     return self.image_processor





