
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,
    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,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__a         =   logging.get_logger(__name__)
class 					lowercase__(							UpperCAmelCase				):



	"""simple docstring"""




	a     :Any       	=      ['pixel_values']
	def __init__(			self    :     Tuple			,				SCREAMING_SNAKE_CASE_    :     bool = True			,				SCREAMING_SNAKE_CASE_    :     Optional[Dict[str, int]] = None			,				SCREAMING_SNAKE_CASE_    :     PILImageResampling = PILImageResampling.BILINEAR			,				SCREAMING_SNAKE_CASE_    :     bool = True			,				SCREAMING_SNAKE_CASE_    :     Dict[str, int] = None			,				SCREAMING_SNAKE_CASE_    :     bool = True			,				SCREAMING_SNAKE_CASE_    :     Union[int, float] = 1 / 2_5_5			,				SCREAMING_SNAKE_CASE_    :     bool = True			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[float, List[float]]] = None			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[float, List[float]]] = None			,				**SCREAMING_SNAKE_CASE_    :     Tuple			,				)			->	None:
					super().__init__(**SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   size if size is not None else {'''shortest_edge''': 2_5_6}
					lowercase_	    =   get_size_dict(SCREAMING_SNAKE_CASE_			,				default_to_square=SCREAMING_SNAKE_CASE_			)
					lowercase_	    =   crop_size if crop_size is not None else {'''height''': 2_2_4, '''width''': 2_2_4}
					lowercase_	    =   get_size_dict(SCREAMING_SNAKE_CASE_			)
					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 IMAGENET_STANDARD_MEAN
					lowercase_	    =   image_std if image_std is not None else IMAGENET_STANDARD_STD
	def 		_lowercase    (			self    :     str			,				SCREAMING_SNAKE_CASE_    :     np.ndarray			,				SCREAMING_SNAKE_CASE_    :     Dict[str, int]			,				SCREAMING_SNAKE_CASE_    :     PILImageResampling = PILImageResampling.BICUBIC			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[str, ChannelDimension]] = None			,				**SCREAMING_SNAKE_CASE_    :     List[str]			,				)			->	np.ndarray:
					lowercase_	    =   get_size_dict(SCREAMING_SNAKE_CASE_			,				default_to_square=SCREAMING_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(SCREAMING_SNAKE_CASE_			,				size=size['''shortest_edge''']			,				default_to_square=SCREAMING_SNAKE_CASE_			)
					return resize(SCREAMING_SNAKE_CASE_			,				size=SCREAMING_SNAKE_CASE_			,				resample=SCREAMING_SNAKE_CASE_			,				data_format=SCREAMING_SNAKE_CASE_			,				**SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     int			,				SCREAMING_SNAKE_CASE_    :     np.ndarray			,				SCREAMING_SNAKE_CASE_    :     Dict[str, int]			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[str, ChannelDimension]] = None			,				**SCREAMING_SNAKE_CASE_    :     Tuple			,				)			->	np.ndarray:
					lowercase_	    =   get_size_dict(SCREAMING_SNAKE_CASE_			)
					return center_crop(SCREAMING_SNAKE_CASE_			,				size=(size['''height'''], size['''width'''])			,				data_format=SCREAMING_SNAKE_CASE_			,				**SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     str			,				SCREAMING_SNAKE_CASE_    :     np.ndarray			,				SCREAMING_SNAKE_CASE_    :     float			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[str, ChannelDimension]] = None			,				**SCREAMING_SNAKE_CASE_    :     List[Any]			)			->	np.ndarray:
					return rescale(SCREAMING_SNAKE_CASE_			,				scale=SCREAMING_SNAKE_CASE_			,				data_format=SCREAMING_SNAKE_CASE_			,				**SCREAMING_SNAKE_CASE_			)
	def 		_lowercase    (			self    :     Union[str, Any]			,				SCREAMING_SNAKE_CASE_    :     np.ndarray			,				SCREAMING_SNAKE_CASE_    :     Union[float, List[float]]			,				SCREAMING_SNAKE_CASE_    :     Union[float, List[float]]			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[str, ChannelDimension]] = None			,				**SCREAMING_SNAKE_CASE_    :     Any			,				)			->	np.ndarray:
					return normalize(SCREAMING_SNAKE_CASE_			,				mean=SCREAMING_SNAKE_CASE_			,				std=SCREAMING_SNAKE_CASE_			,				data_format=SCREAMING_SNAKE_CASE_			,				**SCREAMING_SNAKE_CASE_			)




	def 		_lowercase    (			self    :     int			,				SCREAMING_SNAKE_CASE_    :     ImageInput			,				SCREAMING_SNAKE_CASE_    :     Optional[bool] = None			,				SCREAMING_SNAKE_CASE_    :     Dict[str, int] = None			,				SCREAMING_SNAKE_CASE_    :     PILImageResampling = None			,				SCREAMING_SNAKE_CASE_    :     bool = None			,				SCREAMING_SNAKE_CASE_    :     Dict[str, int] = None			,				SCREAMING_SNAKE_CASE_    :     Optional[bool] = None			,				SCREAMING_SNAKE_CASE_    :     Optional[float] = None			,				SCREAMING_SNAKE_CASE_    :     Optional[bool] = None			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[float, List[float]]] = None			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[float, List[float]]] = None			,				SCREAMING_SNAKE_CASE_    :     Optional[Union[str, TensorType]] = None			,				SCREAMING_SNAKE_CASE_    :     Union[str, ChannelDimension] = ChannelDimension.FIRST			,				**SCREAMING_SNAKE_CASE_    :     Optional[int]			,				)			->	str:
					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(SCREAMING_SNAKE_CASE_			,				default_to_square=SCREAMING_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(SCREAMING_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_	    =   make_list_of_images(SCREAMING_SNAKE_CASE_			)

					if not valid_images(SCREAMING_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.'''			)

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

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

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

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

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

					lowercase_	    =   [to_channel_dimension_format(SCREAMING_SNAKE_CASE_			,				SCREAMING_SNAKE_CASE_			) for image in images]

					lowercase_	    =   {'''pixel_values''': images}
					return BatchFeature(data=SCREAMING_SNAKE_CASE_			,				tensor_type=SCREAMING_SNAKE_CASE_			)










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


__a							     =					{}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __a							     =					['NllbTokenizer']

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __a							     =					['NllbTokenizerFast']


if TYPE_CHECKING:
     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_nllb import NllbTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_nllb_fast import NllbTokenizerFast

else:
     import sys

     __a							     =					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)