


# 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()








from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


snake_case							: Dict      =   logging.get_logger(__name__)







class  snake_case_     (lowerCamelCase_   ):
					UpperCAmelCase__      :					Dict					   =    ['''pixel_values''']
					def __init__(   self     :Optional[Any]    ,__snake_case     :bool = True    ,__snake_case     :int = 32    ,__snake_case     :Union[str, Any]=PILImageResampling.BILINEAR    ,__snake_case     :bool = True    ,**__snake_case     :Tuple    ,)      ->					None:
												a__    =  do_resize
												a__    =  do_rescale
												a__    =  size_divisor
												a__    =  resample
												super().__init__(**__snake_case   )
					def 				lowerCamelCase__(   self     :Union[str, Any]    ,__snake_case     :np.ndarray    ,__snake_case     :int    ,__snake_case     :Tuple    ,__snake_case     :Optional[ChannelDimension] = None    ,**__snake_case     :List[Any]   )      ->					np.ndarray:
												a__   ,      a__    =  get_image_size(__snake_case   )
												# Rounds the height and width down to the closest multiple of size_divisor
												a__    =  height // size_divisor * size_divisor
												a__    =  width // size_divisor * size_divisor
												a__    =  resize(__snake_case    ,(new_h, new_w)    ,resample=__snake_case    ,data_format=__snake_case    ,**__snake_case   )
												return image
					def 				lowerCamelCase__(   self     :List[str]    ,__snake_case     :np.ndarray    ,__snake_case     :float    ,__snake_case     :Optional[ChannelDimension] = None    ,**__snake_case     :str   )      ->					np.ndarray:
												return rescale(image=__snake_case    ,scale=__snake_case    ,data_format=__snake_case    ,**__snake_case   )



					def 				lowerCamelCase__(   self     :Tuple    ,__snake_case     :Union["PIL.Image.Image", TensorType, List["PIL.Image.Image"], List[TensorType]]    ,__snake_case     :Optional[bool] = None    ,__snake_case     :Optional[int] = None    ,__snake_case     :Union[str, Any]=None    ,__snake_case     :Optional[bool] = None    ,__snake_case     :Optional[Union[TensorType, str]] = None    ,__snake_case     :ChannelDimension = ChannelDimension.FIRST    ,**__snake_case     :List[Any]    ,)      ->					BatchFeature:
												a__    =  do_resize if do_resize is not None else self.do_resize
												a__    =  do_rescale if do_rescale is not None else self.do_rescale
												a__    =  size_divisor if size_divisor is not None else self.size_divisor
												a__    =  resample if resample is not None else self.resample

												if do_resize and size_divisor is None:
																			raise ValueError('size_divisor is required for resizing'   )

												a__    =  make_list_of_images(__snake_case   )

												if not valid_images(__snake_case   ):
																			raise ValueError('Invalid image(s)'   )

												# All transformations expect numpy arrays.
												a__    =  [to_numpy_array(__snake_case   ) for img in images]

												if do_resize:
																			a__    =  [self.resize(__snake_case    ,size_divisor=__snake_case    ,resample=__snake_case   ) for image in images]

												if do_rescale:
																			a__    =  [self.rescale(__snake_case    ,scale=1 / 2_55   ) for image in images]

												a__    =  [to_channel_dimension_format(__snake_case    ,__snake_case   ) for image in images]

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




