class_docstr: Constructs a Fuyu processor which wraps a Fuyu image processor and a Llama tokenizer into a single processor.
  
  [`FuyuProcessor`] offers all the functionalities of [`FuyuImageProcessor`] and [`LlamaTokenizerFast`]. See the
  [`~FuyuProcessor.__call__`] and [`~FuyuProcessor.decode`] for more information.
  
  Args:
      image_processor ([`FuyuImageProcessor`]):
          The image processor is a required input.
      tokenizer ([`LlamaTokenizerFast`]):
          The tokenizer is a required input.
class_docstr_tok: ["Constructs","a","Fuyu","processor","which","wraps","a","Fuyu","image","processor","and","a","Llama","tokenizer","into","a","single","processor",".","[","`","FuyuProcessor","`","]","offers","all","the","functionalities","of","[","`","FuyuImageProcessor","`","]","and","[","`","LlamaTokenizerFast","`","]",".","See","the","[","`","~FuyuProcessor.__call__","`","]","and","[","`","~FuyuProcessor.decode","`","]","for","more","information",".","Args",":","image_processor","(","[","`","FuyuImageProcessor","`","]",")",":","The","image","processor","is","a","required","input",".","tokenizer","(","[","`","LlamaTokenizerFast","`","]",")",":","The","tokenizer","is","a","required","input","."]
docstr: Main method to prepare for the model one or several sequences(s) and image(s). This method forwards the `text`
  and `kwargs` arguments to LlamaTokenizerFast's [`~LlamaTokenizerFast.__call__`] if `text` is not `None` to
  encode the text. To prepare the image(s), this method forwards the `images` and `kwargs` arguments to
  FuyuImageProcessor's [`~FuyuImageProcessor.__call__`] if `images` is not `None`. Please refer to the doctsring
  of the above two methods for more information.
  
  Args:
      text (`str`, `List[str]`):
          The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings
          (pretokenized string). If the sequences are provided as list of strings (pretokenized), you must set
          `is_split_into_words=True` (to lift the ambiguity with a batch of sequences).
      images (`PIL.Image.Image`, `List[PIL.Image.Image]`):
          The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
          tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
          number of channels, H and W are image height and width.
  
  Returns:
      [`FuyuBatchEncoding`]: A [`FuyuBatchEncoding`] with the following fields:
  
      - **input_ids** -- Tensor of token ids to be fed to a model. Returned when `text` is not `None`.
      - **image_patches** -- List of Tensor of image patches. Returned when `images` is not `None`.
      - **image_patches_indices** -- Tensor of indices where patch embeddings have to be inserted by the model.
      - **attention_mask** -- List of indices specifying which tokens should be attended to by the model when
        `return_attention_mask=True`.
docstr_tok: ["Main","method","to","prepare","for","the","model","one","or","several","sequences","(","s",")","and","image","(","s",")",".","This","method","forwards","the","`","text","`","and","`","kwargs","`","arguments","to","LlamaTokenizerFast","'s","[","`","~LlamaTokenizerFast.__call__","`","]","if","`","text","`","is","not","`","None","`","to","encode","the","text",".","To","prepare","the","image","(","s",")",",","this","method","forwards","the","`","images","`","and","`","kwargs","`","arguments","to","FuyuImageProcessor","'s","[","`","~FuyuImageProcessor.__call__","`","]","if","`","images","`","is","not","`","None","`",".","Please","refer","to","the","doctsring","of","the","above","two","methods","for","more","information",".","Args",":","text","(","`","str","`",",","`","List","[","str","]","`",")",":","The","sequence","or","batch","of","sequences","to","be","encoded",".","Each","sequence","can","be","a","string","or","a","list","of","strings","(","pretokenized","string",")",".","If","the","sequences","are","provided","as","list","of","strings","(","pretokenized",")",",","you","must","set","`","is_split_into_words=True","`","(","to","lift","the","ambiguity","with","a","batch","of","sequences",")",".","images","(","`","PIL.Image.Image","`",",","`","List","[","PIL.Image.Image","]","`",")",":","The","image","or","batch","of","images","to","be","prepared",".","Each","image","can","be","a","PIL","image",",","NumPy","array","or","PyTorch","tensor",".","In","case","of","a","NumPy","array\/PyTorch","tensor",",","each","image","should","be","of","shape","(","C",",","H",",","W",")",",","where","C","is","a","number","of","channels",",","H","and","W","are","image","height","and","width",".","Returns",":","[","`","FuyuBatchEncoding","`","]",":","A","[","`","FuyuBatchEncoding","`","]","with","the","following","fields",":","-","*","*","input_ids","*","*","--","Tensor","of","token","ids","to","be","fed","to","a","model",".","Returned","when","`","text","`","is","not","`","None","`",".","-","*","*","image_patches","*","*","--","List","of","Tensor","of","image","patches",".","Returned","when","`","images","`","is","not","`","None","`",".","-","*","*","image_patches_indices","*","*","--","Tensor","of","indices","where","patch","embeddings","have","to","be","inserted","by","the","model",".","-","*","*","attention_mask","*","*","--","List","of","indices","specifying","which","tokens","should","be","attended","to","by","the","model","when","`","return_attention_mask=True","`","."]
code: def __call__(
      self,
      text=None,
      images=None,
      add_special_tokens: bool = True,
      return_attention_mask: bool = True,
      padding: Union[bool, str, PaddingStrategy] = False,
      truncation: Union[bool, str, TruncationStrategy] = None,
      max_length: Optional[int] = None,
      stride: int = 0,
      pad_to_multiple_of: Optional[int] = None,
      return_overflowing_tokens: bool = False,
      return_special_tokens_mask: bool = False,
      return_offsets_mapping: bool = False,
      return_token_type_ids: bool = False,
      return_length: bool = False,
      verbose: bool = True,
      return_tensors: Optional[Union[str, TensorType]] = None,
      **kwargs,
  ) -> "FuyuBatchFeature":
      """
      Main method to prepare for the model one or several sequences(s) and image(s). This method forwards the `text`
      and `kwargs` arguments to LlamaTokenizerFast's [`~LlamaTokenizerFast.__call__`] if `text` is not `None` to
      encode the text. To prepare the image(s), this method forwards the `images` and `kwargs` arguments to
      FuyuImageProcessor's [`~FuyuImageProcessor.__call__`] if `images` is not `None`. Please refer to the doctsring
      of the above two methods for more information.
  
      Args:
          text (`str`, `List[str]`):
              The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings
              (pretokenized string). If the sequences are provided as list of strings (pretokenized), you must set
              `is_split_into_words=True` (to lift the ambiguity with a batch of sequences).
          images (`PIL.Image.Image`, `List[PIL.Image.Image]`):
              The image or batch of images to be prepared. Each image can be a PIL image, NumPy array or PyTorch
              tensor. In case of a NumPy array/PyTorch tensor, each image should be of shape (C, H, W), where C is a
              number of channels, H and W are image height and width.
  
      Returns:
          [`FuyuBatchEncoding`]: A [`FuyuBatchEncoding`] with the following fields:
  
          - **input_ids** -- Tensor of token ids to be fed to a model. Returned when `text` is not `None`.
          - **image_patches** -- List of Tensor of image patches. Returned when `images` is not `None`.
          - **image_patches_indices** -- Tensor of indices where patch embeddings have to be inserted by the model.
          - **attention_mask** -- List of indices specifying which tokens should be attended to by the model when
            `return_attention_mask=True`.
      """
      requires_backends(self, ["torch"])
  
      # --- Check input validity ---
      if not return_attention_mask:
          raise ValueError(
              "`return_attention_mask=False` is not supported for this model."
          )
      if text is None and images is None:
          raise ValueError(
              "You have to specify either text or images. Both cannot be None."
          )
      if text is not None and images is None:
          logger.warning(
              "You are processing a text with no associated image. Make sure it is intended."
          )
          self.current_processor = self.tokenizer
          text_encoding = self.tokenizer(
              text=text,
              add_special_tokens=add_special_tokens,
              padding=padding,
              truncation=truncation,
              max_length=max_length,
              stride=stride,
              pad_to_multiple_of=pad_to_multiple_of,
              return_attention_mask=return_attention_mask,
              return_overflowing_tokens=return_overflowing_tokens,
              return_special_tokens_mask=return_special_tokens_mask,
              return_offsets_mapping=return_offsets_mapping,
              return_token_type_ids=return_token_type_ids,
              return_length=return_length,
              verbose=verbose,
              return_tensors=return_tensors,
              **kwargs,
          )
          return text_encoding
  
      if text is None and images is not None:
          logger.warning(
              "You are processing an image with no associated text. Make sure it is intended."
          )
          prompts = [[""]]
      if text is not None and images is not None:
          if isinstance(text, str):
              prompts = [[text]]
          elif isinstance(text, list):
              prompts = [[text_seq] for text_seq in text]
  
      # --- Preprocess images using self.image_processor ---
  
      # FIXME - We hard code "pt" here because the rest of the processing assumes torch tensors
      image_encoding = self.image_processor.preprocess(
          images, return_tensors="pt"
      )
      batch_images = image_encoding["images"]
      image_unpadded_heights = image_encoding["image_unpadded_heights"]
      image_unpadded_widths = image_encoding["image_unpadded_widths"]
      scale_factors = image_encoding["image_scale_factors"]
      self.subsequence_length = (
          1  # Each batch contains only one sequence.
      )
      self.batch_size = len(batch_images)
  
      # --- Use self.tokenizer to get the ids of special tokens to insert into image ids ---
  
      image_placeholder_id = self.tokenizer(
          "|SPEAKER|", add_special_tokens=False
      )["input_ids"][1]
      image_newline_id = self.tokenizer(
          "|NEWLINE|", add_special_tokens=False
      )["input_ids"][1]
      tensor_batch_images = torch.stack(
          [img[0] for img in batch_images]
      ).unsqueeze(1)
  
      # --- Use self.image_processor again to obtain the full token ids and batch inputs ---
      all_encodings = []
  
      for (
          prompt,
          scale_factor,
          image_unpadded_height,
          image_unpadded_width,
          tensor_batch_image,
      ) in zip(
          prompts,
          scale_factors,
          image_unpadded_heights,
          image_unpadded_widths,
          tensor_batch_images,
      ):
          sample_encoding = self.get_sample_encoding(
              prompts=[prompt],
              scale_factors=[scale_factor],
              image_unpadded_heights=torch.tensor(
                  [image_unpadded_height]
              ),
              image_unpadded_widths=torch.tensor(
                  [image_unpadded_width]
              ),
              image_placeholder_id=image_placeholder_id,
              image_newline_id=image_newline_id,
              tensor_batch_images=tensor_batch_image.unsqueeze(0),
          )
          all_encodings.append(sample_encoding)
      batch_encoding = self._left_pad_inputs_with_attention_mask(
          model_inputs=all_encodings,
          return_attention_mask=return_attention_mask,
      )
      return FuyuBatchFeature(data=batch_encoding)
  
imports: import re
  from typing import Dict, List, Optional, Tuple, Union
  import numpy
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import PaddingStrategy, TruncationStrategy
  from ...utils import TensorType, is_torch_available, logging, requires_backends
label_desc: Use image node_id 4 for calling the FuyuProcessor obj's underlying member method code with example usage: obj.__call__(text, images, add_special_tokens, return_attention_mask, padding, truncation, max_length, stride, pad_to_multiple_of, return_overflowing_tokens, return_special_tokens_mask, return_offsets_mapping, return_token_type_ids, return_length, verbose, return_tensors) and returns: FuyuBatchFeature, text_encoding