



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


if is_vision_available():
    import PIL


__UpperCAmelCase          =       logging.get_logger(__name__)
def 		UpperCamelCase	(   snake_case__       :    str	)	->     List[List[ImageInput]]:
   if isinstance(snake_case__       ,     (list, tuple)	) and isinstance(videos[0]       ,     (list, tuple)	) and is_valid_image(videos[0][0]	):
      return videos

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

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

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



class 				lowerCAmelCase_		(  a__							):
       UpperCAmelCase__				:					List[Any]        =  ["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_ = None,			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    :  Dict							=	size if size is not None else {'shortest_edge': 224}
          UpperCamelCase    :  Tuple							=	get_size_dict(SCREAMING_SNAKE_CASE_,			default_to_square=SCREAMING_SNAKE_CASE_       )
          UpperCamelCase    :  List[Any]							=	crop_size if crop_size is not None else {'height': 224, 'width': 224}
          UpperCamelCase    :  Optional[int]							=	get_size_dict(SCREAMING_SNAKE_CASE_,			param_name='crop_size'       )

          UpperCamelCase    :  Dict							=	do_resize
          UpperCamelCase    :  Any							=	size
          UpperCamelCase    :  Any							=	do_center_crop
          UpperCamelCase    :  Optional[Any]							=	crop_size
          UpperCamelCase    :  str							=	resample
          UpperCamelCase    :  str							=	do_rescale
          UpperCamelCase    :  str							=	rescale_factor
          UpperCamelCase    :  Tuple							=	do_normalize
          UpperCamelCase    :  Optional[Any]							=	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
          UpperCamelCase    :  List[str]							=	image_std if image_std is not None else IMAGENET_STANDARD_STD
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_ = PILImageResampling.BILINEAR,			SCREAMING_SNAKE_CASE_ = None,			**SCREAMING_SNAKE_CASE_,			)     ->		np.ndarray:
          UpperCamelCase    :  Optional[Any]							=	get_size_dict(SCREAMING_SNAKE_CASE_,			default_to_square=SCREAMING_SNAKE_CASE_       )
          if "shortest_edge" in size:
             UpperCamelCase    :  int							=	get_resize_output_image_size(SCREAMING_SNAKE_CASE_,			size['shortest_edge'],			default_to_square=SCREAMING_SNAKE_CASE_       )
          elif "height" in size and "width" in size:
             UpperCamelCase    :  Any							=	(size['height'], size['width'])
          else:
             raise ValueError(F"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"""       )
          return resize(SCREAMING_SNAKE_CASE_,			size=SCREAMING_SNAKE_CASE_,			resample=SCREAMING_SNAKE_CASE_,			data_format=SCREAMING_SNAKE_CASE_,			**SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_ = None,			**SCREAMING_SNAKE_CASE_,			)     ->		np.ndarray:
          UpperCamelCase    :  List[Any]							=	get_size_dict(SCREAMING_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(SCREAMING_SNAKE_CASE_,			size=(size['height'], size['width']),			data_format=SCREAMING_SNAKE_CASE_,			**SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_ = None,			**SCREAMING_SNAKE_CASE_,			)     ->		List[str]:
          return rescale(SCREAMING_SNAKE_CASE_,			scale=SCREAMING_SNAKE_CASE_,			data_format=SCREAMING_SNAKE_CASE_,			**SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			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 					snake_case_       (			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_ = None,			SCREAMING_SNAKE_CASE_ = 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.'       )

          # All transformations expect numpy arrays.
          UpperCamelCase    :  str							=	to_numpy_array(SCREAMING_SNAKE_CASE_       )

          if do_resize:
             UpperCamelCase    :  str							=	self.resize(image=SCREAMING_SNAKE_CASE_,			size=SCREAMING_SNAKE_CASE_,			resample=SCREAMING_SNAKE_CASE_       )

          if do_center_crop:
             UpperCamelCase    :  int							=	self.center_crop(SCREAMING_SNAKE_CASE_,			size=SCREAMING_SNAKE_CASE_       )

          if do_rescale:
             UpperCamelCase    :  Dict							=	self.rescale(image=SCREAMING_SNAKE_CASE_,			scale=SCREAMING_SNAKE_CASE_       )

          if do_normalize:
             UpperCamelCase    :  List[str]							=	self.normalize(image=SCREAMING_SNAKE_CASE_,			mean=SCREAMING_SNAKE_CASE_,			std=SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  List[Any]							=	to_channel_dimension_format(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )
          return image






       def 					snake_case_       (			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_ = None,			SCREAMING_SNAKE_CASE_ = None,			SCREAMING_SNAKE_CASE_ = ChannelDimension.FIRST,			**SCREAMING_SNAKE_CASE_,			)     ->		PIL.Image.Image:
          UpperCamelCase    :  Optional[int]							=	do_resize if do_resize is not None else self.do_resize
          UpperCamelCase    :  Tuple							=	resample if resample is not None else self.resample
          UpperCamelCase    :  Optional[int]							=	do_center_crop if do_center_crop is not None else self.do_center_crop
          UpperCamelCase    :  List[Any]							=	do_rescale if do_rescale is not None else self.do_rescale
          UpperCamelCase    :  List[str]							=	rescale_factor if rescale_factor is not None else self.rescale_factor
          UpperCamelCase    :  Tuple							=	do_normalize if do_normalize is not None else self.do_normalize
          UpperCamelCase    :  Tuple							=	image_mean if image_mean is not None else self.image_mean
          UpperCamelCase    :  str							=	image_std if image_std is not None else self.image_std

          UpperCamelCase    :  Dict							=	size if size is not None else self.size
          UpperCamelCase    :  Any							=	get_size_dict(SCREAMING_SNAKE_CASE_,			default_to_square=SCREAMING_SNAKE_CASE_       )
          UpperCamelCase    :  Optional[Any]							=	crop_size if crop_size is not None else self.crop_size
          UpperCamelCase    :  int							=	get_size_dict(SCREAMING_SNAKE_CASE_,			param_name='crop_size'       )

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

          UpperCamelCase    :  Optional[Any]							=	make_batched(SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  List[Any]							=	[
              [
                  self._preprocess_image(
                      image=SCREAMING_SNAKE_CASE_,			do_resize=SCREAMING_SNAKE_CASE_,			size=SCREAMING_SNAKE_CASE_,			resample=SCREAMING_SNAKE_CASE_,			do_center_crop=SCREAMING_SNAKE_CASE_,			crop_size=SCREAMING_SNAKE_CASE_,			do_rescale=SCREAMING_SNAKE_CASE_,			rescale_factor=SCREAMING_SNAKE_CASE_,			do_normalize=SCREAMING_SNAKE_CASE_,			image_mean=SCREAMING_SNAKE_CASE_,			image_std=SCREAMING_SNAKE_CASE_,			data_format=SCREAMING_SNAKE_CASE_,			)
                  for img in video
              ]
              for video in videos
          ]

          UpperCamelCase    :  List[Any]							=	{'pixel_values': videos}
          return BatchFeature(data=SCREAMING_SNAKE_CASE_,			tensor_type=SCREAMING_SNAKE_CASE_       )








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__UpperCAmelCase          =       {
    '''configuration_transfo_xl''': ['''TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TransfoXLConfig'''],
    '''tokenization_transfo_xl''': ['''TransfoXLCorpus''', '''TransfoXLTokenizer'''],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''AdaptiveEmbedding''',
        '''TransfoXLForSequenceClassification''',
        '''TransfoXLLMHeadModel''',
        '''TransfoXLModel''',
        '''TransfoXLPreTrainedModel''',
        '''load_tf_weights_in_transfo_xl''',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''TFAdaptiveEmbedding''',
        '''TFTransfoXLForSequenceClassification''',
        '''TFTransfoXLLMHeadModel''',
        '''TFTransfoXLMainLayer''',
        '''TFTransfoXLModel''',
        '''TFTransfoXLPreTrainedModel''',
    ]


if TYPE_CHECKING:
    from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
    from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_transfo_xl import (
            TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            AdaptiveEmbedding,
            TransfoXLForSequenceClassification,
            TransfoXLLMHeadModel,
            TransfoXLModel,
            TransfoXLPreTrainedModel,
            load_tf_weights_in_transfo_xl,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_transfo_xl import (
            TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFAdaptiveEmbedding,
            TFTransfoXLForSequenceClassification,
            TFTransfoXLLMHeadModel,
            TFTransfoXLMainLayer,
            TFTransfoXLModel,
            TFTransfoXLPreTrainedModel,
        )

else:
    import sys

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



