


from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
						import PIL

snake_case							: Optional[int]      =   logging.get_logger(__name__)






def 							__lowercase     (				__lowerCAmelCase							:       int     ):
							if isinstance(__lowerCAmelCase      ,					(list, tuple)     ) and isinstance(videos[0]      ,					(list, tuple)     ) and is_valid_image(videos[0][0]     ):
														return videos

							elif isinstance(__lowerCAmelCase      ,					(list, tuple)     ) and is_valid_image(videos[0]     ):
														return [videos]

							elif is_valid_image(__lowerCAmelCase     ):
														return [[videos]]

							raise ValueError(F'Could not make batched video from {videos}'     )







class  snake_case_     (lowerCamelCase_   ):
					UpperCAmelCase__      :					Union[str, Any]					   =    ['''pixel_values''']
					def __init__(   self     :Dict    ,__snake_case     :bool = True    ,__snake_case     :Dict[str, int] = None    ,__snake_case     :PILImageResampling = PILImageResampling.BILINEAR    ,__snake_case     :bool = True    ,__snake_case     :Dict[str, int] = None    ,__snake_case     :bool = True    ,__snake_case     :Union[int, float] = 1 / 2_55    ,__snake_case     :bool = True    ,__snake_case     :bool = True    ,__snake_case     :Optional[Union[float, List[float]]] = None    ,__snake_case     :Optional[Union[float, List[float]]] = None    ,**__snake_case     :Optional[int]    ,)      ->					None:
												super().__init__(**__snake_case   )
												a__    =  size if size is not None else {'shortest_edge': 2_56}
												a__    =  get_size_dict(__snake_case    ,default_to_square=__snake_case   )
												a__    =  crop_size if crop_size is not None else {'height': 2_24, 'width': 2_24}
												a__    =  get_size_dict(__snake_case    ,param_name='crop_size'   )

												a__    =  do_resize
												a__    =  size
												a__    =  do_center_crop
												a__    =  crop_size
												a__    =  resample
												a__    =  do_rescale
												a__    =  rescale_factor
												a__    =  offset
												a__    =  do_normalize
												a__    =  image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
												a__    =  image_std if image_std is not None else IMAGENET_STANDARD_STD
					def 				lowerCamelCase__(   self     :Optional[Any]    ,__snake_case     :np.ndarray    ,__snake_case     :Dict[str, int]    ,__snake_case     :PILImageResampling = PILImageResampling.BILINEAR    ,__snake_case     :Optional[Union[str, ChannelDimension]] = None    ,**__snake_case     :str    ,)      ->					np.ndarray:
												a__    =  get_size_dict(__snake_case    ,default_to_square=__snake_case   )
												if "shortest_edge" in size:
																			a__    =  get_resize_output_image_size(__snake_case    ,size['shortest_edge']    ,default_to_square=__snake_case   )
												elif "height" in size and "width" in size:
																			a__    =  (size['height'], size['width'])
												else:
																			raise ValueError(F'Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'   )
												return resize(__snake_case    ,size=__snake_case    ,resample=__snake_case    ,data_format=__snake_case    ,**__snake_case   )
					def 				lowerCamelCase__(   self     :Union[str, Any]    ,__snake_case     :np.ndarray    ,__snake_case     :Dict[str, int]    ,__snake_case     :Optional[Union[str, ChannelDimension]] = None    ,**__snake_case     :str    ,)      ->					np.ndarray:
												a__    =  get_size_dict(__snake_case   )
												if "height" not in size or "width" not in size:
																			raise ValueError(F'Size must have \'height\' and \'width\' as keys. Got {size.keys()}'   )
												return center_crop(__snake_case    ,size=(size['height'], size['width'])    ,data_format=__snake_case    ,**__snake_case   )
					def 				lowerCamelCase__(   self     :List[Any]    ,__snake_case     :np.ndarray    ,__snake_case     :Union[int, float]    ,__snake_case     :bool = True    ,__snake_case     :Optional[Union[str, ChannelDimension]] = None    ,**__snake_case     :str    ,)      ->					Union[str, Any]:
												a__    =  image.astype(np.floataa   )
												if offset:
																			a__    =  image - (scale / 2)
												return rescale(__snake_case    ,scale=__snake_case    ,data_format=__snake_case    ,**__snake_case   )
					def 				lowerCamelCase__(   self     :List[Any]    ,__snake_case     :np.ndarray    ,__snake_case     :Union[float, List[float]]    ,__snake_case     :Union[float, List[float]]    ,__snake_case     :Optional[Union[str, ChannelDimension]] = None    ,**__snake_case     :Union[str, Any]    ,)      ->					np.ndarray:
												return normalize(__snake_case    ,mean=__snake_case    ,std=__snake_case    ,data_format=__snake_case    ,**__snake_case   )
					def 				lowerCamelCase__(   self     :Optional[int]    ,__snake_case     :ImageInput    ,__snake_case     :bool = None    ,__snake_case     :Dict[str, int] = None    ,__snake_case     :PILImageResampling = None    ,__snake_case     :bool = None    ,__snake_case     :Dict[str, int] = None    ,__snake_case     :bool = None    ,__snake_case     :float = None    ,__snake_case     :bool = None    ,__snake_case     :bool = None    ,__snake_case     :Optional[Union[float, List[float]]] = None    ,__snake_case     :Optional[Union[float, List[float]]] = None    ,__snake_case     :Optional[ChannelDimension] = ChannelDimension.FIRST    ,)      ->					np.ndarray:
												if do_resize and size is None or resample is None:
																			raise ValueError('Size and resample 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.'   )

												if offset and not do_rescale:
																			raise ValueError('For offset, do_rescale must also be set to True.'   )

												# All transformations expect numpy arrays.
												a__    =  to_numpy_array(__snake_case   )

												if do_resize:
																			a__    =  self.resize(image=__snake_case    ,size=__snake_case    ,resample=__snake_case   )

												if do_center_crop:
																			a__    =  self.center_crop(__snake_case    ,size=__snake_case   )

												if do_rescale:
																			a__    =  self.rescale(image=__snake_case    ,scale=__snake_case    ,offset=__snake_case   )

												if do_normalize:
																			a__    =  self.normalize(image=__snake_case    ,mean=__snake_case    ,std=__snake_case   )

												a__    =  to_channel_dimension_format(__snake_case    ,__snake_case   )
												return image



					def 				lowerCamelCase__(   self     :Any    ,__snake_case     :ImageInput    ,__snake_case     :bool = None    ,__snake_case     :Dict[str, int] = None    ,__snake_case     :PILImageResampling = None    ,__snake_case     :bool = None    ,__snake_case     :Dict[str, int] = None    ,__snake_case     :bool = None    ,__snake_case     :float = None    ,__snake_case     :bool = None    ,__snake_case     :bool = None    ,__snake_case     :Optional[Union[float, List[float]]] = None    ,__snake_case     :Optional[Union[float, List[float]]] = None    ,__snake_case     :Optional[Union[str, TensorType]] = None    ,__snake_case     :ChannelDimension = ChannelDimension.FIRST    ,**__snake_case     :Any    ,)      ->					PIL.Image.Image:
												a__    =  do_resize if do_resize is not None else self.do_resize
												a__    =  resample if resample is not None else self.resample
												a__    =  do_center_crop if do_center_crop is not None else self.do_center_crop
												a__    =  do_rescale if do_rescale is not None else self.do_rescale
												a__    =  rescale_factor if rescale_factor is not None else self.rescale_factor
												a__    =  offset if offset is not None else self.offset
												a__    =  do_normalize if do_normalize is not None else self.do_normalize
												a__    =  image_mean if image_mean is not None else self.image_mean
												a__    =  image_std if image_std is not None else self.image_std

												a__    =  size if size is not None else self.size
												a__    =  get_size_dict(__snake_case    ,default_to_square=__snake_case   )
												a__    =  crop_size if crop_size is not None else self.crop_size
												a__    =  get_size_dict(__snake_case    ,param_name='crop_size'   )

												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.'   )

												a__    =  make_batched(__snake_case   )

												a__    =  [
												    [
												        self._preprocess_image(
												            image=__snake_case    ,do_resize=__snake_case    ,size=__snake_case    ,resample=__snake_case    ,do_center_crop=__snake_case    ,crop_size=__snake_case    ,do_rescale=__snake_case    ,rescale_factor=__snake_case    ,offset=__snake_case    ,do_normalize=__snake_case    ,image_mean=__snake_case    ,image_std=__snake_case    ,data_format=__snake_case    ,)
												        for img in video
												    ]
												    for video in videos
												]

												a__    =  {'pixel_values': videos}
												return BatchFeature(data=__snake_case    ,tensor_type=__snake_case   )








# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re

from ..utils import cached_file


# docstyle-ignore
snake_case							: Dict      =   '''
Human: <<task>>

Assistant: '''


snake_case							: Optional[int]      =   '''huggingface-tools/default-prompts'''
snake_case							: Tuple      =   {'''chat''': '''chat_prompt_template.txt''', '''run''': '''run_prompt_template.txt'''}






def 							__lowercase     (				__lowerCAmelCase							:       Any      ,					__lowerCAmelCase							:       Union[str, Any]      ,					__lowerCAmelCase							:       Any="run"     ):
							if prompt_or_repo_id is None:
														a__    =  DEFAULT_PROMPTS_REPO

							# prompt is considered a repo ID when it does not contain any kind of space
							if re.search('\\s'      ,					__lowerCAmelCase     ) is not None:
														return prompt_or_repo_id

							a__    =  cached_file(
							    __lowerCAmelCase      ,					PROMPT_FILES[mode]      ,					repo_type='dataset'      ,					user_agent={'agent': agent_name}     )
							with open(__lowerCAmelCase      ,					'r'      ,					encoding='utf-8'     ) as f:
														return f.read()




