






"""simple docstring"""







# Copyright 2023 The HuggingFace 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.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_UpperCamelCase					      =  {
    """configuration_vivit""": ["""VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """VivitConfig"""],
}
try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _UpperCamelCase					      =  ["""VivitImageProcessor"""]


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _UpperCamelCase					      =  [
      """VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """VivitModel""",
      """VivitPreTrainedModel""",
      """VivitForVideoClassification""",
  ]


if TYPE_CHECKING:
  from .configuration_vivit import VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, VivitConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_vivit import VivitImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_vivit import (
        VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
        VivitForVideoClassification,
        VivitModel,
        VivitPreTrainedModel,
    )


else:
  import sys

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











"""simple docstring"""







import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
  from .tokenization_pegasus import PegasusTokenizer
else:
  _UpperCamelCase					      =  None


_UpperCamelCase					      =  logging.get_logger(__name__)


_UpperCamelCase					      =  """▁"""

_UpperCamelCase					      =  {"""vocab_file""": """spiece.model""", """tokenizer_file""": """tokenizer.json"""}

_UpperCamelCase					      =  {
    """vocab_file""": {"""google/pegasus-xsum""": """https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model"""},
    """tokenizer_file""": {
        """google/pegasus-xsum""": """https://huggingface.co/google/pegasus-xsum/resolve/main/tokenizer.json"""
    },
}

_UpperCamelCase					      =  {
    """google/pegasus-xsum""": 512,
}







class  lowerCamelCase__ (	snake_case			):
    SCREAMING_SNAKE_CASE		=      VOCAB_FILES_NAMES
    SCREAMING_SNAKE_CASE		=      PRETRAINED_VOCAB_FILES_MAP
    SCREAMING_SNAKE_CASE		=      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    SCREAMING_SNAKE_CASE		=      PegasusTokenizer
    SCREAMING_SNAKE_CASE		=      ['''input_ids''', '''attention_mask''']






    def __init__(			self     ,A=None     ,A=None     ,A="<pad>"     ,A="</s>"     ,A="<unk>"     ,A="<mask_2>"     ,A="<mask_1>"     ,A=None     ,A=103     ,**A     ,):
          UpperCAmelCase          =	offset

          if additional_special_tokens is not None:
                if not isinstance(A     ,A ):
                      raise TypeError(
                          F'''additional_special_tokens should be of type {type(A )}, but is'''
                          F''' {type(A )}''' )

                UpperCAmelCase          =	(
                    ([mask_token_sent] + additional_special_tokens)
                    if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
                    else additional_special_tokens
                )
                # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
                additional_special_tokens_extended += [
                    F'''<unk_{i}>''' for i in range(len(A )     ,self.offset - 1 )
                ]

                if len(set(A ) ) != len(A ):
                      raise ValueError(
                          """Please make sure that the provided additional_special_tokens do not contain an incorrectly"""
                          F''' shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.''' )
                UpperCAmelCase          =	additional_special_tokens_extended
          else:
                UpperCAmelCase          =	[mask_token_sent] if mask_token_sent is not None else []
                additional_special_tokens += [F'''<unk_{i}>''' for i in range(2     ,self.offset )]

          super().__init__(
              A     ,tokenizer_file=A     ,pad_token=A     ,eos_token=A     ,unk_token=A     ,mask_token=A     ,mask_token_sent=A     ,offset=A     ,additional_special_tokens=A     ,**A     ,)
          UpperCAmelCase          =	vocab_file
          UpperCAmelCase          =	False if not self.vocab_file else True






    def     _UpperCamelCase							(			self     ,A ):
          UpperCAmelCase          =	set(self.all_special_ids )  # call it once instead of inside list comp
          all_special_ids.remove(self.unk_token_id )  # <unk> is only sometimes special

          if all_special_ids != set(range(len(self.additional_special_tokens ) + 3 ) ):
                raise ValueError(
                    """There should be 3 special tokens: mask_token, pad_token, and eos_token +"""
                    F''' {len(self.additional_special_tokens )} additional_special_tokens, but got {all_special_ids}''' )

          return [1 if x in all_special_ids else 0 for x in seq]






    def     _UpperCamelCase							(			self     ,A     ,A = None     ,A = False ):
          if already_has_special_tokens:
                return self._special_token_mask(A )
          elif token_ids_a is None:
                return self._special_token_mask(A ) + [1]
          else:
                return self._special_token_mask(token_ids_a + token_ids_a ) + [1]






    def     _UpperCamelCase							(			self     ,A     ,A=None ):
          if token_ids_a is None:
                return token_ids_a + [self.eos_token_id]
          # We don't expect to process pairs, but leave the pair logic for API consistency
          return token_ids_a + token_ids_a + [self.eos_token_id]






    def     _UpperCamelCase							(			self     ,A     ,A = None ):
          if not self.can_save_slow_tokenizer:
                raise ValueError(
                    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
                    """tokenizer.""" )

          if not os.path.isdir(A ):
                logger.error(F'''Vocabulary path ({save_directory}) should be a directory''' )
                return
          UpperCAmelCase          =	os.path.join(
              A     ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )

          if os.path.abspath(self.vocab_file ) != os.path.abspath(A ):
                copyfile(self.vocab_file     ,A )

          return (out_vocab_file,)



