

"""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  (  )	->						int:
   '''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_     :       Optional[int],			UpperCamelCase_     :       Union[str, Any],			UpperCamelCase_     :       Optional[Any])	->						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_     :       Union[str, Any])	->						List[str]:
   '''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	:					List[Any]   		=	["flattened_patches"]


 def __init__(			self							:			List[str],					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							:			Optional[int],					UpperCAmelCase__							:			np.ndarray,					UpperCAmelCase__							:			int,					UpperCAmelCase__							:			dict,					**UpperCAmelCase__							:			Dict	):
    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							:			List[Any],					UpperCAmelCase__							:			np.ndarray,					UpperCAmelCase__							:			Optional[Union[str, ChannelDimension]] = None,					**UpperCAmelCase__							:			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__							:			Any,					):
    __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"""





from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder


# @@protoc_insertion_point(imports)

_a       =							_symbol_database.Default()


_a       =							_descriptor_pool.Default().AddSerializedFile(
    b'\n\x19sentencepiece_model.proto\x12\rsentencepiece"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18  \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03'
)

_a       =							globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'sentencepiece_model_pb2', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
   _a       =							None
   _a       =							b'H\003'
   # (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
   # _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
   # _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
   # _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
   # _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
   _a       =							45
   _a       =							15_81
   _a       =							15_17
   _a       =							15_70
   _a       =							15_84
   _a       =							17_93
   _a       =							17_95
   _a       =							19_16
   _a       =							18_64
   _a       =							19_05
   _a       =							19_19
   _a       =							24_29
   _a       =							22_08
   _a       =							24_18
   _a       =							23_23
   _a       =							24_07
# @@protoc_insertion_point(module_scope)




