

"""simple docstring"""





import io
import math
from typing import Dict, Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import convert_to_rgb, normalize, to_channel_dimension_format, to_pil_image
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    get_image_size,
    infer_channel_dimension_format,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_vision_available, logging
from ...utils.import_utils import requires_backends


if is_vision_available():
   import textwrap

   from PIL import Image, ImageDraw, ImageFont

if is_torch_available():
   import torch

   from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
   _a							=							False


_a							=							logging.get_logger(__name__)
_a							=							'ybelkada/fonts'




def   _A  (  )     ->						str:
   '''simple docstring'''


   if is_torch_available() and not is_torch_greater_or_equal_than_1_11:
      raise ImportError(
          F"""You are using torch=={torch.__version__}, but torch>=1.11.0 is required to use """
          "Pix2StructImageProcessor. Please upgrade torch.")




def   _A  (  UpperCamelCase_					:	str,      UpperCamelCase_					:	Tuple,      UpperCamelCase_					:	Optional[Any])     ->						Optional[int]:
   '''simple docstring'''


   requires_backends(UpperCamelCase_,      ["torch"])
   _check_torch_version()

   __lowercase								=						image_tensor.unsqueeze(0)
   __lowercase								=						torch.nn.functional.unfold(UpperCamelCase_,      (patch_height, patch_width),      stride=(patch_height, patch_width))
   __lowercase								=						patches.reshape(image_tensor.size(0),      image_tensor.size(1),      UpperCamelCase_,      UpperCamelCase_,      -1)
   __lowercase								=						patches.permute(0,      4,      2,      3,      1).reshape(
       image_tensor.size(2) // patch_height,      image_tensor.size(3) // patch_width,      image_tensor.size(1) * patch_height * patch_width,      )
   return patches.unsqueeze(0)




def   _A  (  UpperCamelCase_					:	str,      UpperCamelCase_					:	int = 36,      UpperCamelCase_					:	str = "black",      UpperCamelCase_					:	str = "white",      UpperCamelCase_					:	int = 5,      UpperCamelCase_					:	int = 5,      UpperCamelCase_					:	int = 5,      UpperCamelCase_					:	int = 5,      UpperCamelCase_					:	Optional[bytes] = None,      UpperCamelCase_					:	Optional[str] = None,      )     ->						Image.Image:
   '''simple docstring'''


   requires_backends(UpperCamelCase_,      "vision")
   # Add new lines so that each line is no more than 80 characters.

   __lowercase								=						textwrap.TextWrapper(width=80)
   __lowercase								=						wrapper.wrap(text=UpperCamelCase_)
   __lowercase								=						"\n".join(UpperCamelCase_)

   if font_bytes is not None and font_path is None:
      __lowercase								=						io.BytesIO(UpperCamelCase_)
   elif font_path is not None:
      __lowercase								=						font_path
   else:
      __lowercase								=						hf_hub_download(UpperCamelCase_,      "Arial.TTF")
   __lowercase								=						ImageFont.truetype(UpperCamelCase_,      encoding="UTF-8",      size=UpperCamelCase_)

   # Use a temporary canvas to determine the width and height in pixels when
   # rendering the text.
   __lowercase								=						ImageDraw.Draw(Image.new("RGB",      (1, 1),      UpperCamelCase_))
   __lowercase		,__lowercase		,__lowercase		,__lowercase								=						temp_draw.textbbox((0, 0),      UpperCamelCase_,      UpperCamelCase_)

   # Create the actual image with a bit of padding around the text.
   __lowercase								=						text_width + left_padding + right_padding
   __lowercase								=						text_height + top_padding + bottom_padding
   __lowercase								=						Image.new("RGB",      (image_width, image_height),      UpperCamelCase_)
   __lowercase								=						ImageDraw.Draw(UpperCamelCase_)
   draw.text(xy=(left_padding, top_padding),      text=UpperCamelCase_,      fill=UpperCamelCase_,      font=UpperCamelCase_)
   return image




def   _A  (  UpperCamelCase_					:	np.ndarray,      UpperCamelCase_					:	str,      **UpperCamelCase_					:	Dict)     ->						Tuple:
   '''simple docstring'''


   requires_backends(UpperCamelCase_,      "vision")

   # Convert to PIL image if necessary
   __lowercase								=						to_pil_image(UpperCamelCase_)

   __lowercase								=						render_text(UpperCamelCase_,      **UpperCamelCase_)
   __lowercase								=						max(header_image.width,      image.width)

   __lowercase								=						int(image.height * (new_width / image.width))
   __lowercase								=						int(header_image.height * (new_width / header_image.width))

   __lowercase								=						Image.new("RGB",      (new_width, new_height + new_header_height),      "white")
   new_image.paste(header_image.resize((new_width, new_header_height)),      (0, 0))
   new_image.paste(image.resize((new_width, new_height)),      (0, new_header_height))

   # Convert back to the original framework if necessary
   __lowercase								=						to_numpy_array(UpperCamelCase_)

   if infer_channel_dimension_format(UpperCamelCase_) == ChannelDimension.LAST:
      __lowercase								=						to_channel_dimension_format(UpperCamelCase_,      ChannelDimension.LAST)

   return new_image




class  _lowerCAmelCase  (     lowercase       ):







 """simple docstring"""







 __UpperCAmelCase     : Any       		=     ["flattened_patches"]


 def __init__(      self							:      Dict, UpperCAmelCase__							:      bool = True, UpperCAmelCase__							:      bool = True, UpperCAmelCase__							:      Dict[str, int] = None, UpperCAmelCase__							:      int = 2_0_4_8, UpperCAmelCase__							:      bool = False, **UpperCAmelCase__							:      Dict, ):
    super().__init__(**UpperCAmelCase__     )
    __lowercase								=						patch_size if patch_size is not None else {"height": 1_6, "width": 1_6}
    __lowercase								=						do_normalize
    __lowercase								=						do_convert_rgb
    __lowercase								=						max_patches
    __lowercase								=						is_vqa


 def  _lowercase			(      self							:      List[Any], UpperCAmelCase__							:      np.ndarray, UpperCAmelCase__							:      int, UpperCAmelCase__							:      dict, **UpperCAmelCase__							:      Optional[Any]     ):
    requires_backends(self.extract_flattened_patches, "torch"     )
    _check_torch_version()

    # convert to torch
    __lowercase								=						to_channel_dimension_format(UpperCAmelCase__, ChannelDimension.FIRST     )
    __lowercase								=						torch.from_numpy(UpperCAmelCase__     )

    __lowercase		,__lowercase								=						patch_size["height"], patch_size["width"]
    __lowercase		,__lowercase								=						get_image_size(UpperCAmelCase__     )

    # maximize scale s.t.
    __lowercase								=						math.sqrt(max_patches * (patch_height / image_height) * (patch_width / image_width)     )
    __lowercase								=						max(min(math.floor(scale * image_height / patch_height     ), UpperCAmelCase__     ), 1     )
    __lowercase								=						max(min(math.floor(scale * image_width / patch_width     ), UpperCAmelCase__     ), 1     )
    __lowercase								=						max(num_feasible_rows * patch_height, 1     )
    __lowercase								=						max(num_feasible_cols * patch_width, 1     )

    __lowercase								=						torch.nn.functional.interpolate(
        image.unsqueeze(0     ), size=(resized_height, resized_width), mode="bilinear", align_corners=UpperCAmelCase__, antialias=UpperCAmelCase__, ).squeeze(0     )

    # [1, rows, columns, patch_height * patch_width * image_channels]
    __lowercase								=						torch_extract_patches(UpperCAmelCase__, UpperCAmelCase__, UpperCAmelCase__     )

    __lowercase								=						patches.shape
    __lowercase								=						patches_shape[1]
    __lowercase								=						patches_shape[2]
    __lowercase								=						patches_shape[3]

    # [rows * columns, patch_height * patch_width * image_channels]
    __lowercase								=						patches.reshape([rows * columns, depth]     )

    # [rows * columns, 1]
    __lowercase								=						torch.arange(UpperCAmelCase__     ).reshape([rows, 1]     ).repeat(1, UpperCAmelCase__     ).reshape([rows * columns, 1]     )
    __lowercase								=						torch.arange(UpperCAmelCase__     ).reshape([1, columns]     ).repeat(UpperCAmelCase__, 1     ).reshape([rows * columns, 1]     )

    # Offset by 1 so the ids do not contain zeros, which represent padding.
    row_ids += 1
    col_ids += 1

    # Prepare additional patch features.
    # [rows * columns, 1]
    __lowercase								=						row_ids.to(torch.floataa     )
    __lowercase								=						col_ids.to(torch.floataa     )

    # [rows * columns, 2 + patch_height * patch_width * image_channels]
    __lowercase								=						torch.cat([row_ids, col_ids, patches], -1     )

    # [max_patches, 2 + patch_height * patch_width * image_channels]
    __lowercase								=						torch.nn.functional.pad(UpperCAmelCase__, [0, 0, 0, max_patches - (rows * columns)]     ).float()

    __lowercase								=						to_numpy_array(UpperCAmelCase__     )

    return result


 def  _lowercase			(      self							:      Dict, UpperCAmelCase__							:      np.ndarray, UpperCAmelCase__							:      Optional[Union[str, ChannelDimension]] = None, **UpperCAmelCase__							:      List[Any]     ):
    if image.dtype == np.uinta:
       __lowercase								=						image.astype(np.floataa     )

    # take mean across the whole `image`
    __lowercase								=						np.mean(UpperCAmelCase__     )
    __lowercase								=						np.std(UpperCAmelCase__     )
    __lowercase								=						max(UpperCAmelCase__, 1.0 / math.sqrt(np.prod(image.shape     )     )     )

    return normalize(UpperCAmelCase__, mean=UpperCAmelCase__, std=UpperCAmelCase__, **UpperCAmelCase__     )



 def  _lowercase			(      self							:      Dict, UpperCAmelCase__							:      ImageInput, UpperCAmelCase__							:      Optional[str] = None, UpperCAmelCase__							:      bool = None, UpperCAmelCase__							:      Optional[bool] = None, UpperCAmelCase__							:      Optional[int] = None, UpperCAmelCase__							:      Optional[Dict[str, int]] = None, UpperCAmelCase__							:      Optional[Union[str, TensorType]] = None, UpperCAmelCase__							:      ChannelDimension = ChannelDimension.FIRST, **UpperCAmelCase__							:      Optional[int], ):
    __lowercase								=						do_normalize if do_normalize is not None else self.do_normalize
    __lowercase								=						do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
    __lowercase								=						patch_size if patch_size is not None else self.patch_size
    __lowercase								=						max_patches if max_patches is not None else self.max_patches
    __lowercase								=						self.is_vqa

    if kwargs.get("data_format", UpperCAmelCase__     ) is not None:
       raise ValueError("data_format is not an accepted input as the outputs are "     )

    __lowercase								=						make_list_of_images(UpperCAmelCase__     )

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

    # PIL RGBA images are converted to RGB
    if do_convert_rgb:
       __lowercase								=						[convert_to_rgb(UpperCAmelCase__     ) for image in images]

    # All transformations expect numpy arrays.
    __lowercase								=						[to_numpy_array(UpperCAmelCase__     ) for image in images]

    if is_vqa:
       if header_text is None:
          raise ValueError("A header text must be provided for VQA models."     )
       __lowercase								=						kwargs.pop("font_bytes", UpperCAmelCase__     )
       __lowercase								=						kwargs.pop("font_path", UpperCAmelCase__     )

       if isinstance(UpperCAmelCase__, UpperCAmelCase__     ):
          __lowercase								=						[header_text] * len(UpperCAmelCase__     )

       __lowercase								=						[
           render_header(UpperCAmelCase__, header_text[i], font_bytes=UpperCAmelCase__, font_path=UpperCAmelCase__     )
           for i, image in enumerate(UpperCAmelCase__     )
       ]

    if do_normalize:
       __lowercase								=						[self.normalize(image=UpperCAmelCase__     ) for image in images]

    # convert to torch tensor and permute
    __lowercase								=						[
        self.extract_flattened_patches(image=UpperCAmelCase__, max_patches=UpperCAmelCase__, patch_size=UpperCAmelCase__     )
        for image in images
    ]

    # create attention mask in numpy
    __lowercase								=						[(image.sum(axis=-1     ) != 0).astype(np.floataa     ) for image in images]

    __lowercase								=						BatchFeature(
        data={"flattened_patches": images, "attention_mask": attention_masks}, tensor_type=UpperCAmelCase__     )

    return encoded_outputs







"""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_funnel import FunnelTokenizer


_a							=							logging.get_logger(__name__)

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

_a							=							[
    'small',
    'small-base',
    'medium',
    'medium-base',
    'intermediate',
    'intermediate-base',
    'large',
    'large-base',
    'xlarge',
    'xlarge-base',
]

_a							=							{
    'vocab_file': {
        'funnel-transformer/small': 'https://huggingface.co/funnel-transformer/small/resolve/main/vocab.txt',
        'funnel-transformer/small-base': 'https://huggingface.co/funnel-transformer/small-base/resolve/main/vocab.txt',
        'funnel-transformer/medium': 'https://huggingface.co/funnel-transformer/medium/resolve/main/vocab.txt',
        'funnel-transformer/medium-base': (
            'https://huggingface.co/funnel-transformer/medium-base/resolve/main/vocab.txt'
        ),
        'funnel-transformer/intermediate': (
            'https://huggingface.co/funnel-transformer/intermediate/resolve/main/vocab.txt'
        ),
        'funnel-transformer/intermediate-base': (
            'https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/vocab.txt'
        ),
        'funnel-transformer/large': 'https://huggingface.co/funnel-transformer/large/resolve/main/vocab.txt',
        'funnel-transformer/large-base': 'https://huggingface.co/funnel-transformer/large-base/resolve/main/vocab.txt',
        'funnel-transformer/xlarge': 'https://huggingface.co/funnel-transformer/xlarge/resolve/main/vocab.txt',
        'funnel-transformer/xlarge-base': (
            'https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'funnel-transformer/small': 'https://huggingface.co/funnel-transformer/small/resolve/main/tokenizer.json',
        'funnel-transformer/small-base': (
            'https://huggingface.co/funnel-transformer/small-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/medium': 'https://huggingface.co/funnel-transformer/medium/resolve/main/tokenizer.json',
        'funnel-transformer/medium-base': (
            'https://huggingface.co/funnel-transformer/medium-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/intermediate': (
            'https://huggingface.co/funnel-transformer/intermediate/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/intermediate-base': (
            'https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/large': 'https://huggingface.co/funnel-transformer/large/resolve/main/tokenizer.json',
        'funnel-transformer/large-base': (
            'https://huggingface.co/funnel-transformer/large-base/resolve/main/tokenizer.json'
        ),
        'funnel-transformer/xlarge': 'https://huggingface.co/funnel-transformer/xlarge/resolve/main/tokenizer.json',
        'funnel-transformer/xlarge-base': (
            'https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/tokenizer.json'
        ),
    },
}
_a							=							{F"funnel-transformer/{name}": 5_12 for name in _model_names}
_a							=							{F"funnel-transformer/{name}": {'do_lower_case': True} for name in _model_names}




class  _lowerCAmelCase  (     lowercase       ):







 """simple docstring"""







 __UpperCAmelCase     : Optional[Any]       		=     VOCAB_FILES_NAMES
 __UpperCAmelCase     : Tuple       		=     PRETRAINED_VOCAB_FILES_MAP
 __UpperCAmelCase     : Union[str, Any]       		=     PRETRAINED_INIT_CONFIGURATION
 __UpperCAmelCase     : Optional[Any]       		=     FunnelTokenizer
 __UpperCAmelCase     : List[str]       		=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __UpperCAmelCase     : int       		=     2


 def __init__(      self							:      Dict, UpperCAmelCase__							:      Dict=None, UpperCAmelCase__							:      Optional[int]=None, UpperCAmelCase__							:      Dict=True, UpperCAmelCase__							:      List[str]="<unk>", UpperCAmelCase__							:      Optional[Any]="<sep>", UpperCAmelCase__							:      Optional[Any]="<pad>", UpperCAmelCase__							:      Union[str, Any]="<cls>", UpperCAmelCase__							:      str="<mask>", UpperCAmelCase__							:      Optional[Any]="<s>", UpperCAmelCase__							:      Tuple="</s>", UpperCAmelCase__							:      Union[str, Any]=True, UpperCAmelCase__							:      Optional[int]=True, UpperCAmelCase__							:      Optional[Any]=None, UpperCAmelCase__							:      Dict="##", **UpperCAmelCase__							:      List[str], ):
    super().__init__(
        UpperCAmelCase__, tokenizer_file=UpperCAmelCase__, do_lower_case=UpperCAmelCase__, unk_token=UpperCAmelCase__, sep_token=UpperCAmelCase__, pad_token=UpperCAmelCase__, cls_token=UpperCAmelCase__, mask_token=UpperCAmelCase__, bos_token=UpperCAmelCase__, eos_token=UpperCAmelCase__, clean_text=UpperCAmelCase__, tokenize_chinese_chars=UpperCAmelCase__, strip_accents=UpperCAmelCase__, wordpieces_prefix=UpperCAmelCase__, **UpperCAmelCase__, )

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

    __lowercase								=						do_lower_case


 def  _lowercase			(      self							:      Tuple, UpperCAmelCase__							:      Any, UpperCAmelCase__							:      Any=None     ):
    __lowercase								=						[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  _lowercase			(      self							:      str, UpperCAmelCase__							:      List[int], UpperCAmelCase__							:      Optional[List[int]] = None     ):
    __lowercase								=						[self.sep_token_id]
    __lowercase								=						[self.cls_token_id]
    if token_ids_a is None:
       return len(cls     ) * [self.cls_token_type_id] + len(token_ids_a + sep     ) * [0]
    return len(cls     ) * [self.cls_token_type_id] + len(token_ids_a + sep     ) * [0] + len(token_ids_a + sep     ) * [1]



 def  _lowercase			(      self							:      Optional[Any], UpperCAmelCase__							:      str, UpperCAmelCase__							:      Optional[str] = None     ):
    __lowercase								=						self._tokenizer.model.save(UpperCAmelCase__, name=UpperCAmelCase__     )
    return tuple(UpperCAmelCase__     )




