

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

lowercase_       		=  logging.get_logger(__name__)
def 						_snake_case(    SCREAMING_SNAKE_CASE__			:	int      )							->      List[List[ImageInput]]:





    '''simple docstring'''






    if isinstance(SCREAMING_SNAKE_CASE__    ,			(list, tuple)      ) and isinstance(videos[0]    ,			(list, tuple)      ) and is_valid_image(videos[0][0]      ):
        return videos

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

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

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


class  A						(							_UpperCAmelCase ):







    """simple docstring"""





    lowerCamelCase			=							['pixel_values']


    def __init__(      self :       List[Any],lowercase_ :       bool = True,lowercase_ :       Dict[str, int] = None,lowercase_ :       PILImageResampling = PILImageResampling.BILINEAR,lowercase_ :       bool = True,lowercase_ :       Dict[str, int] = None,lowercase_ :       bool = True,lowercase_ :       Union[int, float] = 1 / 2_5_5,lowercase_ :       bool = True,lowercase_ :       bool = True,lowercase_ :       Optional[Union[float, List[float]]] = None,lowercase_ :       Optional[Union[float, List[float]]] = None,**lowercase_ :       Any,)->    None:





        '''simple docstring'''







        super().__init__(**lowercase_		)
        A__          =   size if size is not None else {'shortest_edge': 2_5_6}
        A__          =   get_size_dict(lowercase_,default_to_square=lowercase_		)
        A__          =   crop_size if crop_size is not None else {'height': 2_2_4, 'width': 2_2_4}
        A__          =   get_size_dict(lowercase_,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 						snake_case__     (      self :       Any,lowercase_ :       np.ndarray,lowercase_ :       Dict[str, int],lowercase_ :       PILImageResampling = PILImageResampling.BILINEAR,lowercase_ :       Optional[Union[str, ChannelDimension]] = None,**lowercase_ :       Tuple,)->    np.ndarray:





        '''simple docstring'''







        A__          =   get_size_dict(lowercase_,default_to_square=lowercase_		)
        if "shortest_edge" in size:
            A__          =   get_resize_output_image_size(lowercase_,size['shortest_edge'],default_to_square=lowercase_		)
        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(lowercase_,size=lowercase_,resample=lowercase_,data_format=lowercase_,**lowercase_		)


    def 						snake_case__     (      self :       str,lowercase_ :       np.ndarray,lowercase_ :       Dict[str, int],lowercase_ :       Optional[Union[str, ChannelDimension]] = None,**lowercase_ :       Tuple,)->    np.ndarray:





        '''simple docstring'''







        A__          =   get_size_dict(lowercase_		)
        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(lowercase_,size=(size['height'], size['width']),data_format=lowercase_,**lowercase_		)


    def 						snake_case__     (      self :       Tuple,lowercase_ :       np.ndarray,lowercase_ :       Union[int, float],lowercase_ :       bool = True,lowercase_ :       Optional[Union[str, ChannelDimension]] = None,**lowercase_ :       Tuple,)->    str:





        '''simple docstring'''







        A__          =   image.astype(np.floataa		)
        if offset:
            A__          =   image - (scale / 2)
        return rescale(lowercase_,scale=lowercase_,data_format=lowercase_,**lowercase_		)


    def 						snake_case__     (      self :       List[Any],lowercase_ :       np.ndarray,lowercase_ :       Union[float, List[float]],lowercase_ :       Union[float, List[float]],lowercase_ :       Optional[Union[str, ChannelDimension]] = None,**lowercase_ :       List[str],)->    np.ndarray:





        '''simple docstring'''







        return normalize(lowercase_,mean=lowercase_,std=lowercase_,data_format=lowercase_,**lowercase_		)


    def 						snake_case__     (      self :       List[Any],lowercase_ :       ImageInput,lowercase_ :       bool = None,lowercase_ :       Dict[str, int] = None,lowercase_ :       PILImageResampling = None,lowercase_ :       bool = None,lowercase_ :       Dict[str, int] = None,lowercase_ :       bool = None,lowercase_ :       float = None,lowercase_ :       bool = None,lowercase_ :       bool = None,lowercase_ :       Optional[Union[float, List[float]]] = None,lowercase_ :       Optional[Union[float, List[float]]] = None,lowercase_ :       Optional[ChannelDimension] = ChannelDimension.FIRST,)->    np.ndarray:





        '''simple docstring'''







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

        if do_resize:
            A__          =   self.resize(image=lowercase_,size=lowercase_,resample=lowercase_		)

        if do_center_crop:
            A__          =   self.center_crop(lowercase_,size=lowercase_		)

        if do_rescale:
            A__          =   self.rescale(image=lowercase_,scale=lowercase_,offset=lowercase_		)

        if do_normalize:
            A__          =   self.normalize(image=lowercase_,mean=lowercase_,std=lowercase_		)

        A__          =   to_channel_dimension_format(lowercase_,lowercase_		)
        return image


    def 						snake_case__     (      self :       Any,lowercase_ :       ImageInput,lowercase_ :       bool = None,lowercase_ :       Dict[str, int] = None,lowercase_ :       PILImageResampling = None,lowercase_ :       bool = None,lowercase_ :       Dict[str, int] = None,lowercase_ :       bool = None,lowercase_ :       float = None,lowercase_ :       bool = None,lowercase_ :       bool = None,lowercase_ :       Optional[Union[float, List[float]]] = None,lowercase_ :       Optional[Union[float, List[float]]] = None,lowercase_ :       Optional[Union[str, TensorType]] = None,lowercase_ :       ChannelDimension = ChannelDimension.FIRST,**lowercase_ :       Tuple,)->    PIL.Image.Image:





        '''simple docstring'''







        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(lowercase_,default_to_square=lowercase_		)
        A__          =   crop_size if crop_size is not None else self.crop_size
        A__          =   get_size_dict(lowercase_,param_name='crop_size'		)

        if not valid_images(lowercase_		):
            raise ValueError(
                'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
                'torch.Tensor, tf.Tensor or jax.ndarray.'		)

        A__          =   make_batched(lowercase_		)

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

        A__          =   {'pixel_values': videos}
        return BatchFeature(data=lowercase_,tensor_type=lowercase_		)


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


_SCREAMING_SNAKE_CASE										=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE										=						{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

_SCREAMING_SNAKE_CASE										=						{
    'vocab_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/vocab.txt',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/vocab.txt',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'
        ),
        'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt',
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'
        ),
        'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt',
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'
        ),
        'bert-base-multilingual-cased': (
            'https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-cased': (
            'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'
        ),
    },
}

_SCREAMING_SNAKE_CASE										=						{
    'bert-base-uncased': 512,
    'bert-large-uncased': 512,
    'bert-base-cased': 512,
    'bert-large-cased': 512,
    'bert-base-multilingual-uncased': 512,
    'bert-base-multilingual-cased': 512,
    'bert-base-chinese': 512,
    'bert-base-german-cased': 512,
    'bert-large-uncased-whole-word-masking': 512,
    'bert-large-cased-whole-word-masking': 512,
    'bert-large-uncased-whole-word-masking-finetuned-squad': 512,
    'bert-large-cased-whole-word-masking-finetuned-squad': 512,
    'bert-base-cased-finetuned-mrpc': 512,
    'bert-base-german-dbmdz-cased': 512,
    'bert-base-german-dbmdz-uncased': 512,
    'TurkuNLP/bert-base-finnish-cased-v1': 512,
    'TurkuNLP/bert-base-finnish-uncased-v1': 512,
    'wietsedv/bert-base-dutch-cased': 512,
}

_SCREAMING_SNAKE_CASE										=						{
    'bert-base-uncased': {'do_lower_case': True},
    'bert-large-uncased': {'do_lower_case': True},
    'bert-base-cased': {'do_lower_case': False},
    'bert-large-cased': {'do_lower_case': False},
    'bert-base-multilingual-uncased': {'do_lower_case': True},
    'bert-base-multilingual-cased': {'do_lower_case': False},
    'bert-base-chinese': {'do_lower_case': False},
    'bert-base-german-cased': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking-finetuned-squad': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking-finetuned-squad': {'do_lower_case': False},
    'bert-base-cased-finetuned-mrpc': {'do_lower_case': False},
    'bert-base-german-dbmdz-cased': {'do_lower_case': False},
    'bert-base-german-dbmdz-uncased': {'do_lower_case': True},
    'TurkuNLP/bert-base-finnish-cased-v1': {'do_lower_case': False},
    'TurkuNLP/bert-base-finnish-uncased-v1': {'do_lower_case': True},
    'wietsedv/bert-base-dutch-cased': {'do_lower_case': False},
}



class 				a							(			__lowerCAmelCase       ):







 """simple docstring"""






 lowerCamelCase	:Tuple    			=		VOCAB_FILES_NAMES
 lowerCamelCase	:Union[str, Any]    			=		PRETRAINED_VOCAB_FILES_MAP
 lowerCamelCase	:Dict    			=		PRETRAINED_INIT_CONFIGURATION
 lowerCamelCase	:Optional[Any]    			=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowerCamelCase	:Optional[Any]    			=		BertTokenizer



 def __init__(					self		,				lowerCAmelCase_=None		,				lowerCAmelCase_=None		,				lowerCAmelCase_=True		,				lowerCAmelCase_="[UNK]"		,				lowerCAmelCase_="[SEP]"		,				lowerCAmelCase_="[PAD]"		,				lowerCAmelCase_="[CLS]"		,				lowerCAmelCase_="[MASK]"		,				lowerCAmelCase_=True		,				lowerCAmelCase_=None		,				**lowerCAmelCase_		,				)  ->					List[str]:
        super().__init__(
            lowerCAmelCase_		,				tokenizer_file=lowerCAmelCase_		,				do_lower_case=lowerCAmelCase_		,				unk_token=lowerCAmelCase_		,				sep_token=lowerCAmelCase_		,				pad_token=lowerCAmelCase_		,				cls_token=lowerCAmelCase_		,				mask_token=lowerCAmelCase_		,				tokenize_chinese_chars=lowerCAmelCase_		,				strip_accents=lowerCAmelCase_		,				**lowerCAmelCase_		,				)

        _A        =  json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
        if (
            normalizer_state.get("""lowercase"""		,				lowerCAmelCase_							) != do_lower_case
            or normalizer_state.get("""strip_accents"""		,				lowerCAmelCase_							) != strip_accents
            or normalizer_state.get("""handle_chinese_chars"""		,				lowerCAmelCase_							) != tokenize_chinese_chars
        ):
               _A        =  getattr(lowerCAmelCase_		,				normalizer_state.pop("""type"""							)							)
               _A        =  do_lower_case
               _A        =  strip_accents
               _A        =  tokenize_chinese_chars
               _A        =  normalizer_class(**lowerCAmelCase_							)

        _A        =  do_lower_case



 def      UpperCAmelCase							(					self		,				lowerCAmelCase_		,				lowerCAmelCase_=None							)  ->					List[str]:
        _A        =  [self.cls_token_id] + token_ids_a + [self.sep_token_id]

        if token_ids_a:
               output += token_ids_a + [self.sep_token_id]

        return output



 def      UpperCAmelCase							(					self		,				lowerCAmelCase_		,				lowerCAmelCase_ = None							)  ->					List[int]:
        _A        =  [self.sep_token_id]
        _A        =  [self.cls_token_id]
        if token_ids_a is None:
               return len(cls + token_ids_a + sep							) * [0]
        return len(cls + token_ids_a + sep							) * [0] + len(token_ids_a + sep							) * [1]



 def      UpperCAmelCase							(					self		,				lowerCAmelCase_		,				lowerCAmelCase_ = None							)  ->					Tuple[str]:
        _A        =  self._tokenizer.model.save(lowerCAmelCase_		,				name=lowerCAmelCase_							)
        return tuple(lowerCAmelCase_							)




