






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 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


__snake_case							      =						logging.get_logger(__name__)







class     UpperCAmelCase_		(      lowercase				):



      """simple docstring"""
      UpperCamelCase_       :      List[str]     =['pixel_values']
      def __init__(       self					,       SCREAMING_SNAKE_CASE_ = True					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = PILImageResampling.BILINEAR					,       SCREAMING_SNAKE_CASE_ = True					,       SCREAMING_SNAKE_CASE_ = 1 / 255					,       SCREAMING_SNAKE_CASE_ = True					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       **SCREAMING_SNAKE_CASE_					,       )       ->   None:
          super().__init__(**SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :List[str]										=     size if size is not None else {'''height''': 224, '''width''': 224}
          UpperCamelCase :List[Any]										=     get_size_dict(SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :Optional[Any]										=     do_resize
          UpperCamelCase :Dict										=     do_rescale
          UpperCamelCase :Optional[int]										=     do_normalize
          UpperCamelCase :Any										=     size
          UpperCamelCase :Tuple										=     resample
          UpperCamelCase :Union[str, Any]										=     rescale_factor
          UpperCamelCase :List[str]										=     image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
          UpperCamelCase :str										=     image_std if image_std is not None else IMAGENET_STANDARD_STD
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_ = PILImageResampling.BILINEAR					,       SCREAMING_SNAKE_CASE_ = None					,       **SCREAMING_SNAKE_CASE_					,       )       ->   np.ndarray:
          UpperCamelCase :str										=     get_size_dict(SCREAMING_SNAKE_CASE_				)
          if "height" not in size or "width" not in size:
              raise ValueError(F'''The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}'''				)
          return resize(
              SCREAMING_SNAKE_CASE_					,       size=(size['''height'''], size['''width'''])					,       resample=SCREAMING_SNAKE_CASE_					,       data_format=SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_ = None					,       **SCREAMING_SNAKE_CASE_				)       ->   np.ndarray:
          return rescale(SCREAMING_SNAKE_CASE_					,       scale=SCREAMING_SNAKE_CASE_					,       data_format=SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_ = None					,       **SCREAMING_SNAKE_CASE_					,       )       ->   np.ndarray:
          return normalize(SCREAMING_SNAKE_CASE_					,       mean=SCREAMING_SNAKE_CASE_					,       std=SCREAMING_SNAKE_CASE_					,       data_format=SCREAMING_SNAKE_CASE_					,       **SCREAMING_SNAKE_CASE_				)




      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = None					,       SCREAMING_SNAKE_CASE_ = ChannelDimension.FIRST					,       **SCREAMING_SNAKE_CASE_					,       )       ->   int:
          UpperCamelCase :Any										=     do_resize if do_resize is not None else self.do_resize
          UpperCamelCase :Tuple										=     do_rescale if do_rescale is not None else self.do_rescale
          UpperCamelCase :List[Any]										=     do_normalize if do_normalize is not None else self.do_normalize
          UpperCamelCase :Union[str, Any]										=     resample if resample is not None else self.resample
          UpperCamelCase :List[str]										=     rescale_factor if rescale_factor is not None else self.rescale_factor
          UpperCamelCase :Tuple										=     image_mean if image_mean is not None else self.image_mean
          UpperCamelCase :Any										=     image_std if image_std is not None else self.image_std

          UpperCamelCase :int										=     size if size is not None else self.size
          UpperCamelCase :str										=     get_size_dict(SCREAMING_SNAKE_CASE_				)

          UpperCamelCase :Union[str, Any]										=     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_rescale and rescale_factor is None:
              raise ValueError('''Rescale factor must be specified if do_rescale is True.'''				)

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

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

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

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

          UpperCamelCase :List[str]										=     [to_channel_dimension_format(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				) for image in images]

          UpperCamelCase :Dict										=     {'''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,
)


__snake_case							      =						{
    """configuration_open_llama""": ["""OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """OpenLlamaConfig"""],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __snake_case							      =						["""LlamaTokenizer"""]

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __snake_case							      =						["""LlamaTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __snake_case							      =						[
     """OpenLlamaForCausalLM""",
     """OpenLlamaModel""",
     """OpenLlamaPreTrainedModel""",
     """OpenLlamaForSequenceClassification""",
 ]


if TYPE_CHECKING:
 from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from transformers import LlamaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from transformers import LlamaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_open_llama import (
      OpenLlamaForCausalLM,
      OpenLlamaForSequenceClassification,
      OpenLlamaModel,
      OpenLlamaPreTrainedModel,
  )


else:
 import sys

 __snake_case							      =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





