
import enum
import warnings

from ..tokenization_utils import TruncationStrategy
from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
	import tensorflow as tf

	from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

if is_torch_available():
	from ..models.auto.modeling_auto import MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

UpperCAmelCase	      = logging.get_logger(__name__)







class        A_   (			enum.Enum   ):




	'''simple docstring'''


	_UpperCamelCase     :     List[str]							 =       0
	_UpperCamelCase     :     Optional[int]							 =       1







@add_end_docstrings(__lowerCamelCase   )
class        A_   (			__lowerCamelCase   ):




	'''simple docstring'''


	_UpperCamelCase     :     Dict							 =       """generated"""





	def __init__(       self		,    *snake_case		,    **snake_case       ):
		super().__init__(*snake_case		,    **snake_case       )

		self.check_model_type(
		    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
		    if self.framework == 'tf'
		    else MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case=None		,    snake_case=None		,    snake_case=None		,    snake_case=None		,    snake_case=None		,    snake_case=None		,    **snake_case		,    ):
		lowercase       =    {}
		if truncation is not None:
			lowercase       =    truncation

		lowercase       =    generate_kwargs

		lowercase       =    {}
		if return_tensors is not None and return_type is None:
			lowercase       =    ReturnType.TENSORS if return_tensors else ReturnType.TEXT
		if return_type is not None:
			lowercase       =    return_type

		if clean_up_tokenization_spaces is not None:
			lowercase       =    clean_up_tokenization_spaces

		if stop_sequence is not None:
			lowercase       =    self.tokenizer.encode(snake_case		,    add_special_tokens=snake_case       )
			if len(snake_case       ) > 1:
				warnings.warn(
				    'Stopping on a multiple token sequence is not yet supported on transformers. The first token of'
				    ' the stop sequence will be used as the stop sequence string in the interim.'       )
			lowercase       =    stop_sequence_ids[0]

		return preprocess_params, forward_params, postprocess_params





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case       ):
		return True





	def 	SCREAMING_SNAKE_CASE__						(       self		,    *snake_case		,    snake_case       ):
		lowercase       =    self.model.config.prefix if self.model.config.prefix is not None else ''
		if isinstance(args[0]		,    snake_case       ):
			if self.tokenizer.pad_token_id is None:
				raise ValueError('Please make sure that the tokenizer has a pad_token_id when using a batch input'       )
			lowercase       =    ([prefix + arg for arg in args[0]],)
			lowercase       =    True

		elif isinstance(args[0]		,    snake_case       ):
			lowercase       =    (prefix + args[0],)
			lowercase       =    False
		else:
			raise ValueError(
			    F''' `args[0]`: {args[0]} have the wrong format. The should be either of type `str` or type `list`'''       )
		lowercase       =    self.tokenizer(*snake_case		,    padding=snake_case		,    truncation=snake_case		,    return_tensors=self.framework       )
		# This is produced by tokenizers but is an invalid generate kwargs
		if "token_type_ids" in inputs:
			del inputs["token_type_ids"]
		return inputs





	def __call__(       self		,    *snake_case		,    **snake_case       ):
		lowercase       =    super().__call__(*snake_case		,    **snake_case       )
		if (
		    isinstance(args[0]		,    snake_case       )
		    and all(isinstance(snake_case		,    snake_case       ) for el in args[0]       )
		    and all(len(snake_case       ) == 1 for res in result       )
		):
			return [res[0] for res in result]
		return result





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case=TruncationStrategy.DO_NOT_TRUNCATE		,    **snake_case       ):
		lowercase       =    self._parse_and_tokenize(snake_case		,    truncation=snake_case		,    **snake_case       )
		return inputs





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    **snake_case       ):
		if self.framework == "pt":
			lowercase  ,					lowercase       =    model_inputs['input_ids'].shape
		elif self.framework == "tf":
			lowercase  ,					lowercase       =    tf.shape(model_inputs['input_ids']       ).numpy()

		lowercase       =    generate_kwargs.get('min_length'		,    self.model.config.min_length       )
		lowercase       =    generate_kwargs.get('max_length'		,    self.model.config.max_length       )
		self.check_inputs(snake_case		,    generate_kwargs['min_length']		,    generate_kwargs['max_length']       )
		lowercase       =    self.model.generate(**snake_case		,    **snake_case       )
		lowercase       =    output_ids.shape[0]
		if self.framework == "pt":
			lowercase       =    output_ids.reshape(snake_case		,    out_b // in_b		,    *output_ids.shape[1:]       )
		elif self.framework == "tf":
			lowercase       =    tf.reshape(snake_case		,    (in_b, out_b // in_b, *output_ids.shape[1:])       )
		return {"output_ids": output_ids}





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case=ReturnType.TEXT		,    snake_case=False       ):
		lowercase       =    []
		for output_ids in model_outputs["output_ids"][0]:
			if return_type == ReturnType.TENSORS:
				lowercase       =    {F'''{self.return_name}_token_ids''': output_ids}
			elif return_type == ReturnType.TEXT:
				lowercase       =    {
				    F'''{self.return_name}_text''': self.tokenizer.decode(
				        snake_case		,    skip_special_tokens=snake_case		,    clean_up_tokenization_spaces=snake_case		,    )
				}
			records.append(snake_case       )
		return records







@add_end_docstrings(__lowerCamelCase   )
class        A_   (			__lowerCamelCase   ):




	'''simple docstring'''


	_UpperCamelCase     :     Union[str, Any]							 =       """summary"""





	def __call__(       self		,    *snake_case		,    **snake_case       ):
		return super().__call__(*snake_case		,    **snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case       ):
		if max_length < min_length:
			logger.warning(F'''Your min_length={min_length} must be inferior than your max_length={max_length}.'''       )

		if input_length < max_length:
			logger.warning(
			    F'''Your max_length is set to {max_length}, but your input_length is only {input_length}. Since this is '''
			    'a summarization task, where outputs shorter than the input are typically wanted, you might '
			    F'''consider decreasing max_length manually, e.g. summarizer(\'...\', max_length={input_length//2})'''       )







@add_end_docstrings(__lowerCamelCase   )
class        A_   (			__lowerCamelCase   ):




	'''simple docstring'''


	_UpperCamelCase     :     int							 =       """translation"""





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case       ):
		if input_length > 0.9 * max_length:
			logger.warning(
			    F'''Your input_length: {input_length} is bigger than 0.9 * max_length: {max_length}. You might consider '''
			    'increasing your max_length manually, e.g. translator(\'...\', max_length=400)'       )
		return True





	def 	SCREAMING_SNAKE_CASE__						(       self		,    *snake_case		,    snake_case=TruncationStrategy.DO_NOT_TRUNCATE		,    snake_case=None		,    snake_case=None       ):
		if getattr(self.tokenizer		,    '_build_translation_inputs'		,    snake_case       ):
			return self.tokenizer._build_translation_inputs(
			    *snake_case		,    return_tensors=self.framework		,    truncation=snake_case		,    src_lang=snake_case		,    tgt_lang=snake_case       )
		else:
			return super()._parse_and_tokenize(*snake_case		,    truncation=snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case=None		,    snake_case=None		,    **snake_case       ):
		lowercase  ,					lowercase  ,					lowercase       =    super()._sanitize_parameters(**snake_case       )
		if src_lang is not None:
			lowercase       =    src_lang
		if tgt_lang is not None:
			lowercase       =    tgt_lang
		if src_lang is None and tgt_lang is None:
			# Backward compatibility, direct arguments use is preferred.
			lowercase       =    kwargs.get('task'		,    self.task       )
			lowercase       =    task.split('_'       )
			if task and len(snake_case       ) == 4:
				# translation, XX, to YY
				lowercase       =    items[1]
				lowercase       =    items[3]
		return preprocess_params, forward_params, postprocess_params





	def __call__(       self		,    *snake_case		,    **snake_case       ):
		return super().__call__(*snake_case		,    **snake_case       )



from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


UpperCAmelCase	      = logging.get_logger(__name__)


if is_vision_available():
	import PIL







class        A_   (			__lowerCamelCase   ):




	'''simple docstring'''


	_UpperCamelCase     :     str							 =       ["""pixel_values"""]





	def __init__(       self		,    snake_case = True		,    snake_case = None		,    snake_case = PILImageResampling.BICUBIC		,    snake_case = True		,    snake_case = None		,    snake_case = True		,    snake_case = 1 / 255		,    snake_case = True		,    snake_case = None		,    snake_case = None		,    snake_case = True		,    **snake_case		,    ):
		super().__init__(**snake_case       )
		lowercase       =    size if size is not None else {'shortest_edge': 224}
		lowercase       =    get_size_dict(snake_case		,    default_to_square=snake_case       )
		lowercase       =    crop_size if crop_size is not None else {'height': 224, 'width': 224}
		lowercase       =    get_size_dict(snake_case		,    default_to_square=snake_case		,    param_name='crop_size'       )

		lowercase       =    do_resize
		lowercase       =    size
		lowercase       =    resample
		lowercase       =    do_center_crop
		lowercase       =    crop_size
		lowercase       =    do_rescale
		lowercase       =    rescale_factor
		lowercase       =    do_normalize
		lowercase       =    image_mean if image_mean is not None else OPENAI_CLIP_MEAN
		lowercase       =    image_std if image_std is not None else OPENAI_CLIP_STD
		lowercase       =    do_convert_rgb





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case = PILImageResampling.BICUBIC		,    snake_case = None		,    **snake_case		,    ):
		lowercase       =    get_size_dict(snake_case		,    default_to_square=snake_case       )
		if "shortest_edge" not in size:
			raise ValueError(F'''The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'''       )
		lowercase       =    get_resize_output_image_size(snake_case		,    size=size['shortest_edge']		,    default_to_square=snake_case       )
		return resize(snake_case		,    size=snake_case		,    resample=snake_case		,    data_format=snake_case		,    **snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case = None		,    **snake_case		,    ):
		lowercase       =    get_size_dict(snake_case       )
		if "height" not in size or "width" not in size:
			raise ValueError(F'''The `size` parameter must contain the keys (height, width). Got {size.keys()}'''       )
		return center_crop(snake_case		,    size=(size['height'], size['width'])		,    data_format=snake_case		,    **snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case = None		,    **snake_case		,    ):
		return rescale(snake_case		,    scale=snake_case		,    data_format=snake_case		,    **snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case		,    snake_case = None		,    **snake_case		,    ):
		return normalize(snake_case		,    mean=snake_case		,    std=snake_case		,    data_format=snake_case		,    **snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = None		,    snake_case = ChannelDimension.FIRST		,    **snake_case		,    ):
		lowercase       =    do_resize if do_resize is not None else self.do_resize
		lowercase       =    size if size is not None else self.size
		lowercase       =    get_size_dict(snake_case		,    param_name='size'		,    default_to_square=snake_case       )
		lowercase       =    resample if resample is not None else self.resample
		lowercase       =    do_center_crop if do_center_crop is not None else self.do_center_crop
		lowercase       =    crop_size if crop_size is not None else self.crop_size
		lowercase       =    get_size_dict(snake_case		,    param_name='crop_size'		,    default_to_square=snake_case       )
		lowercase       =    do_rescale if do_rescale is not None else self.do_rescale
		lowercase       =    rescale_factor if rescale_factor is not None else self.rescale_factor
		lowercase       =    do_normalize if do_normalize is not None else self.do_normalize
		lowercase       =    image_mean if image_mean is not None else self.image_mean
		lowercase       =    image_std if image_std is not None else self.image_std
		lowercase       =    do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

		lowercase       =    make_list_of_images(snake_case       )

		if not valid_images(snake_case       ):
			raise ValueError(
			    'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
			    'torch.Tensor, tf.Tensor or jax.ndarray.'       )

		if do_resize and size is None:
			raise ValueError('Size must be specified if do_resize is True.'       )

		if do_center_crop and crop_size is None:
			raise ValueError('Crop size must be specified if do_center_crop is True.'       )

		if do_rescale and rescale_factor is None:
			raise ValueError('Rescale factor must be specified if do_rescale is True.'       )

		if do_normalize and (image_mean is None or image_std is None):
			raise ValueError('Image mean and std must be specified if do_normalize is True.'       )

		# PIL RGBA images are converted to RGB
		if do_convert_rgb:
			lowercase       =    [convert_to_rgb(snake_case       ) for image in images]

		# All transformations expect numpy arrays.
		lowercase       =    [to_numpy_array(snake_case       ) for image in images]

		if do_resize:
			lowercase       =    [self.resize(image=snake_case		,    size=snake_case		,    resample=snake_case       ) for image in images]

		if do_center_crop:
			lowercase       =    [self.center_crop(image=snake_case		,    size=snake_case       ) for image in images]

		if do_rescale:
			lowercase       =    [self.rescale(image=snake_case		,    scale=snake_case       ) for image in images]

		if do_normalize:
			lowercase       =    [self.normalize(image=snake_case		,    mean=snake_case		,    std=snake_case       ) for image in images]

		lowercase       =    [to_channel_dimension_format(snake_case		,    snake_case       ) for image in images]

		lowercase       =    {'pixel_values': images}
		return BatchFeature(data=snake_case		,    tensor_type=snake_case       )

