






'''simple docstring'''
from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
  from PIL import Image

  from ..image_utils import load_image

if is_tf_available():
  from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_VISION_2_SEQ_MAPPING

if is_torch_available():
  import torch

  from ..models.auto.modeling_auto import MODEL_FOR_VISION_2_SEQ_MAPPING

a_					= logging.get_logger(__name__)






@add_end_docstrings(lowerCamelCase				)
class      __SCREAMING_SNAKE_CASE      (			lowerCamelCase				):




 def __init__(      self	:							Any					,      *__lowercase	:							List[Any]					,      **__lowercase	:							List[Any]      )	->						Union[str, Any]:
  super().__init__(*__lowercase					,      **__lowercase      )
  requires_backends(self					,      '''vision'''      )
  self.check_model_type(
      TF_MODEL_FOR_VISION_2_SEQ_MAPPING if self.framework == '''tf''' else MODEL_FOR_VISION_2_SEQ_MAPPING      )




 def      __magic_name__	(      self	:							Union[str, Any]					,      __lowercase	:							str=None					,      __lowercase	:							str=None					,      __lowercase	:							Any=None      )	->						Any:
  SCREAMING_SNAKE_CASE__     :				List[Any]									={}
  SCREAMING_SNAKE_CASE__     :				Tuple									={}

  if prompt is not None:
   SCREAMING_SNAKE_CASE__     :				Optional[int]									=prompt

  if generate_kwargs is not None:
   SCREAMING_SNAKE_CASE__     :				int									=generate_kwargs
  if max_new_tokens is not None:
   if "generate_kwargs" not in forward_kwargs:
    SCREAMING_SNAKE_CASE__     :				Optional[int]									={}
   if "max_new_tokens" in forward_kwargs["generate_kwargs"]:
    raise ValueError(
        '''\'max_new_tokens\' is defined twice, once in \'generate_kwargs\' and once as a direct parameter,'''
        ''' please use only one'''      )
   SCREAMING_SNAKE_CASE__     :				List[str]									=max_new_tokens
  return preprocess_params, forward_kwargs, {}




 def __call__(      self	:							Any					,      __lowercase	:							Union[str, List[str], "Image.Image", List["Image.Image"]]					,      **__lowercase	:							Optional[int]      )	->						Tuple:
  return super().__call__(__lowercase					,      **__lowercase      )




 def      __magic_name__	(      self	:							int					,      __lowercase	:							str					,      __lowercase	:							str=None      )	->						Optional[Any]:
  SCREAMING_SNAKE_CASE__     :				str									=load_image(__lowercase      )

  if prompt is not None:
   if not isinstance(__lowercase					,      __lowercase      ):
    raise ValueError(
        F"Received an invalid text input, got - {type(__lowercase      )} - but expected a single string. "
        '''Note also that one single text can be provided for conditional image to text generation.'''      )

   SCREAMING_SNAKE_CASE__     :				Tuple									=self.model.config.model_type

   if model_type == "git":
    SCREAMING_SNAKE_CASE__     :				Any									=self.image_processor(images=__lowercase					,      return_tensors=self.framework      )
    SCREAMING_SNAKE_CASE__     :				List[str]									=self.tokenizer(text=__lowercase					,      add_special_tokens=__lowercase      ).input_ids
    SCREAMING_SNAKE_CASE__     :				Optional[int]									=[self.tokenizer.cls_token_id] + input_ids
    SCREAMING_SNAKE_CASE__     :				str									=torch.tensor(__lowercase      ).unsqueeze(0      )
    model_inputs.update({'''input_ids''': input_ids}      )

   elif model_type == "pix2struct":
    SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=self.image_processor(images=__lowercase					,      header_text=__lowercase					,      return_tensors=self.framework      )

   elif model_type != "vision-encoder-decoder":
    # vision-encoder-decoder does not support conditional generation
    SCREAMING_SNAKE_CASE__     :				List[str]									=self.image_processor(images=__lowercase					,      return_tensors=self.framework      )
    SCREAMING_SNAKE_CASE__     :				Dict									=self.tokenizer(__lowercase					,      return_tensors=self.framework      )
    model_inputs.update(__lowercase      )

   else:
    raise ValueError(F"Model type {model_type} does not support conditional text generation"      )

  else:
   SCREAMING_SNAKE_CASE__     :				List[Any]									=self.image_processor(images=__lowercase					,      return_tensors=self.framework      )

  if self.model.config.model_type == "git" and prompt is None:
   SCREAMING_SNAKE_CASE__     :				List[Any]									=None

  return model_inputs




 def      __magic_name__	(      self	:							int					,      __lowercase	:							Any					,      __lowercase	:							Optional[int]=None      )	->						Optional[int]:
  # Git model sets `model_inputs["input_ids"] = None` in `preprocess` (when `prompt=None`). In batch model, the
  # pipeline will group them into a list of `None`, which fail `_forward`. Avoid this by checking it first.
  if (
      "input_ids" in model_inputs
      and isinstance(model_inputs['''input_ids''']					,      __lowercase      )
      and all(x is None for x in model_inputs['''input_ids''']      )
  ):
   SCREAMING_SNAKE_CASE__     :				List[Any]									=None

  if generate_kwargs is None:
   SCREAMING_SNAKE_CASE__     :				Any									={}
  # FIXME: We need to pop here due to a difference in how `generation.py` and `generation.tf_utils.py`
  #  parse inputs. In the Tensorflow version, `generate` raises an error if we don't use `input_ids` whereas
  #  the PyTorch version matches it with `self.model.main_input_name` or `self.model.encoder.main_input_name`
  #  in the `_prepare_model_inputs` method.
  SCREAMING_SNAKE_CASE__     :				int									=model_inputs.pop(self.model.main_input_name      )
  SCREAMING_SNAKE_CASE__     :				int									=self.model.generate(__lowercase					,      **__lowercase					,      **__lowercase      )
  return model_outputs




 def      __magic_name__	(      self	:							int					,      __lowercase	:							Dict      )	->						str:
  SCREAMING_SNAKE_CASE__     :				Any									=[]
  for output_ids in model_outputs:
   SCREAMING_SNAKE_CASE__     :				Optional[Any]									={
       '''generated_text''': self.tokenizer.decode(
           __lowercase					,      skip_special_tokens=__lowercase					,      )
   }
   records.append(__lowercase      )
  return records







'''simple docstring'''
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


a_					= logging.get_logger(__name__)

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

a_					= {
    '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'
        ),
    },
}

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

a_					= {
    '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      __SCREAMING_SNAKE_CASE      (			lowerCamelCase				):
 snake_case_  							=							VOCAB_FILES_NAMES
 snake_case_  							=							PRETRAINED_VOCAB_FILES_MAP
 snake_case_  							=							PRETRAINED_INIT_CONFIGURATION
 snake_case_  							=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 snake_case_  							=							BertTokenizer




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

       SCREAMING_SNAKE_CASE__     :				str									=json.loads(self.backend_tokenizer.normalizer.__getstate__()      )
       if (
           normalizer_state.get('''lowercase'''					,      __lowercase      ) != do_lower_case
           or normalizer_state.get('''strip_accents'''					,      __lowercase      ) != strip_accents
           or normalizer_state.get('''handle_chinese_chars'''					,      __lowercase      ) != tokenize_chinese_chars
       ):
             SCREAMING_SNAKE_CASE__     :				int									=getattr(__lowercase					,      normalizer_state.pop('''type'''      )      )
             SCREAMING_SNAKE_CASE__     :				Any									=do_lower_case
             SCREAMING_SNAKE_CASE__     :				Any									=strip_accents
             SCREAMING_SNAKE_CASE__     :				Dict									=tokenize_chinese_chars
             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=normalizer_class(**__lowercase      )

       SCREAMING_SNAKE_CASE__     :				Optional[int]									=do_lower_case




 def      __magic_name__	(      self	:							int					,      __lowercase	:							Optional[Any]					,      __lowercase	:							Union[str, Any]=None      )	->						int:
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=[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      __magic_name__	(      self	:							Union[str, Any]					,      __lowercase	:							List[int]					,      __lowercase	:							Optional[List[int]] = None      )	->						List[int]:
       SCREAMING_SNAKE_CASE__     :				List[str]									=[self.sep_token_id]
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=[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      __magic_name__	(      self	:							List[Any]					,      __lowercase	:							str					,      __lowercase	:							Optional[str] = None      )	->						Tuple[str]:
       SCREAMING_SNAKE_CASE__     :				Optional[int]									=self._tokenizer.model.save(__lowercase					,      name=__lowercase      )
       return tuple(__lowercase      )