



'''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:
							__SCREAMING_SNAKE_CASE           =  False


__SCREAMING_SNAKE_CASE           =  logging.get_logger(__name__)
__SCREAMING_SNAKE_CASE           =  """ybelkada/fonts"""




def 	UpperCAmelCase   (						):






			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 	UpperCAmelCase   (						_lowerCamelCase ,    _lowerCamelCase ,    _lowerCamelCase    ):
			requires_backends(_UpperCamelCase ,    ["torch"]    )
			_check_torch_version()

			A							:					List[str]              =						image_tensor.unsqueeze(0    )
			A							:					Dict              =						torch.nn.functional.unfold(_UpperCamelCase ,    (patch_height, patch_width) ,    stride=(patch_height, patch_width)    )
			A							:					Dict              =						patches.reshape(image_tensor.size(0    ) ,    image_tensor.size(1    ) ,    _UpperCamelCase ,    _UpperCamelCase ,    -1    )
			A							:					Union[str, Any]              =						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 	UpperCAmelCase   (						_lowerCamelCase ,    _lowerCamelCase = 36 ,    _lowerCamelCase = "black" ,    _lowerCamelCase = "white" ,    _lowerCamelCase = 5 ,    _lowerCamelCase = 5 ,    _lowerCamelCase = 5 ,    _lowerCamelCase = 5 ,    _lowerCamelCase = None ,    _lowerCamelCase = None ,    ):
			requires_backends(_UpperCamelCase ,    "vision"    )
			# Add new lines so that each line is no more than 80 characters.

			A							:					List[str]              =						textwrap.TextWrapper(width=80    )
			A							:					Union[str, Any]              =						wrapper.wrap(text=_UpperCamelCase    )
			A							:					Optional[Any]              =						"\n".join(_UpperCamelCase    )

			if font_bytes is not None and font_path is None:
						A							:					Optional[int]              =						io.BytesIO(_UpperCamelCase    )
			elif font_path is not None:
						A							:					Union[str, Any]              =						font_path
			else:
						A							:					Dict              =						hf_hub_download(_UpperCamelCase ,    "Arial.TTF"    )
			A							:					Dict              =						ImageFont.truetype(_UpperCamelCase ,    encoding="UTF-8" ,    size=_UpperCamelCase    )

			# Use a temporary canvas to determine the width and height in pixels when
			# rendering the text.
			A							:					Tuple              =						ImageDraw.Draw(Image.new("RGB" ,    (1, 1) ,    _UpperCamelCase    )    )
			A       , A       , A       , A							:					List[str]              =						temp_draw.textbbox((0, 0) ,    _UpperCamelCase ,    _UpperCamelCase    )

			# Create the actual image with a bit of padding around the text.
			A							:					Optional[int]              =						text_width + left_padding + right_padding
			A							:					int              =						text_height + top_padding + bottom_padding
			A							:					int              =						Image.new("RGB" ,    (image_width, image_height) ,    _UpperCamelCase    )
			A							:					Tuple              =						ImageDraw.Draw(_UpperCamelCase    )
			draw.text(xy=(left_padding, top_padding) ,    text=_UpperCamelCase ,    fill=_UpperCamelCase ,    font=_UpperCamelCase    )
			return image




def 	UpperCAmelCase   (						_lowerCamelCase ,    _lowerCamelCase ,    **_lowerCamelCase    ):
			requires_backends(_UpperCamelCase ,    "vision"    )

			# Convert to PIL image if necessary
			A							:					Any              =						to_pil_image(_UpperCamelCase    )

			A							:					Union[str, Any]              =						render_text(_UpperCamelCase ,    **_UpperCamelCase    )
			A							:					Optional[Any]              =						max(header_image.width ,    image.width    )

			A							:					List[str]              =						int(image.height * (new_width / image.width)    )
			A							:					Union[str, Any]              =						int(header_image.height * (new_width / header_image.width)    )

			A							:					str              =						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
			A							:					Tuple              =						to_numpy_array(_UpperCamelCase    )

			if infer_channel_dimension_format(_UpperCamelCase    ) == ChannelDimension.LAST:
						A							:					Optional[Any]              =						to_channel_dimension_format(_UpperCamelCase ,    ChannelDimension.LAST    )

			return new_image






class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''
						a__   =  ["""flattened_patches"""]







						def __init__(	self      :			Union[str, Any]	,	__lowerCamelCase      :			Dict = True	,	__lowerCamelCase      :			Any = True	,	__lowerCamelCase      :			int = None	,	__lowerCamelCase      :			List[Any] = 20_48	,	__lowerCamelCase      :			Optional[Any] = False	,	**__lowerCamelCase      :			Any	,	)      ->				List[Any]:
									super().__init__(**__lowerCamelCase )
									A							:					Dict              =						patch_size if patch_size is not None else {"height": 16, "width": 16}
									A							:					Optional[int]              =						do_normalize
									A							:					int              =						do_convert_rgb
									A							:					str              =						max_patches
									A							:					Optional[Any]              =						is_vqa







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Tuple	,	__lowerCamelCase      :			int	,	__lowerCamelCase      :			Any	,	__lowerCamelCase      :			List[Any]	,	**__lowerCamelCase      :			int )      ->				Optional[Any]:
									requires_backends(self.extract_flattened_patches	,	"torch" )
									_check_torch_version()

									# convert to torch
									A							:					Optional[Any]              =						to_channel_dimension_format(__lowerCamelCase	,	ChannelDimension.FIRST )
									A							:					Any              =						torch.from_numpy(__lowerCamelCase )

									A       , A							:					Optional[int]              =						patch_size["height"], patch_size["width"]
									A       , A							:					int              =						get_image_size(__lowerCamelCase )

									# maximize scale s.t.
									A							:					Union[str, Any]              =						math.sqrt(max_patches * (patch_height / image_height) * (patch_width / image_width) )
									A							:					Dict              =						max(min(math.floor(scale * image_height / patch_height )	,	__lowerCamelCase )	,	1 )
									A							:					str              =						max(min(math.floor(scale * image_width / patch_width )	,	__lowerCamelCase )	,	1 )
									A							:					str              =						max(num_feasible_rows * patch_height	,	1 )
									A							:					Dict              =						max(num_feasible_cols * patch_width	,	1 )

									A							:					Optional[Any]              =						torch.nn.functional.interpolate(
									    image.unsqueeze(0 )	,	size=(resized_height, resized_width)	,	mode="bilinear"	,	align_corners=__lowerCamelCase	,	antialias=__lowerCamelCase	,	).squeeze(0 )

									# [1, rows, columns, patch_height * patch_width * image_channels]
									A							:					Optional[int]              =						torch_extract_patches(__lowerCamelCase	,	__lowerCamelCase	,	__lowerCamelCase )

									A							:					int              =						patches.shape
									A							:					int              =						patches_shape[1]
									A							:					List[Any]              =						patches_shape[2]
									A							:					Tuple              =						patches_shape[3]

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

									# [rows * columns, 1]
									A							:					Any              =						torch.arange(__lowerCamelCase ).reshape([rows, 1] ).repeat(1	,	__lowerCamelCase ).reshape([rows * columns, 1] )
									A							:					List[Any]              =						torch.arange(__lowerCamelCase ).reshape([1, columns] ).repeat(__lowerCamelCase	,	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]
									A							:					List[str]              =						row_ids.to(torch.floataa )
									A							:					str              =						col_ids.to(torch.floataa )

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

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

									A							:					List[str]              =						to_numpy_array(__lowerCamelCase )

									return result







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Tuple	,	__lowerCamelCase      :			Union[str, Any]	,	__lowerCamelCase      :			int = None	,	**__lowerCamelCase      :			str )      ->				Tuple:

									if image.dtype == np.uinta:
												A							:					List[Any]              =						image.astype(np.floataa )

									# take mean across the whole `image`
									A							:					List[Any]              =						np.mean(__lowerCamelCase )
									A							:					Optional[int]              =						np.std(__lowerCamelCase )
									A							:					Optional[int]              =						max(__lowerCamelCase	,	1.0 / math.sqrt(np.prod(image.shape ) ) )

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Tuple	,	__lowerCamelCase      :			List[str]	,	__lowerCamelCase      :			Any = None	,	__lowerCamelCase      :			Tuple = None	,	__lowerCamelCase      :			List[Any] = None	,	__lowerCamelCase      :			Tuple = None	,	__lowerCamelCase      :			Optional[Any] = None	,	__lowerCamelCase      :			Union[str, Any] = None	,	__lowerCamelCase      :			Union[str, Any] = ChannelDimension.FIRST	,	**__lowerCamelCase      :			Optional[Any]	,	)      ->				List[Any]:
									A							:					List[str]              =						do_normalize if do_normalize is not None else self.do_normalize
									A							:					Any              =						do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
									A							:					List[Any]              =						patch_size if patch_size is not None else self.patch_size
									A							:					Dict              =						max_patches if max_patches is not None else self.max_patches
									A							:					Optional[int]              =						self.is_vqa

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

									A							:					Optional[Any]              =						make_list_of_images(__lowerCamelCase )

									if not valid_images(__lowerCamelCase ):
												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:
												A							:					int              =						[convert_to_rgb(__lowerCamelCase ) for image in images]

									# All transformations expect numpy arrays.
									A							:					Optional[int]              =						[to_numpy_array(__lowerCamelCase ) for image in images]

									if is_vqa:
												if header_text is None:
															raise ValueError("A header text must be provided for VQA models." )
												A							:					List[str]              =						kwargs.pop("font_bytes"	,	__lowerCamelCase )
												A							:					str              =						kwargs.pop("font_path"	,	__lowerCamelCase )

												if isinstance(__lowerCamelCase	,	__lowerCamelCase ):
															A							:					List[Any]              =						[header_text] * len(__lowerCamelCase )

												A							:					Tuple              =						[
												    render_header(__lowerCamelCase	,	header_text[i]	,	font_bytes=__lowerCamelCase	,	font_path=__lowerCamelCase )
												    for i, image in enumerate(__lowerCamelCase )
												]

									if do_normalize:
												A							:					int              =						[self.normalize(image=__lowerCamelCase ) for image in images]

									# convert to torch tensor and permute
									A							:					int              =						[
									    self.extract_flattened_patches(image=__lowerCamelCase	,	max_patches=__lowerCamelCase	,	patch_size=__lowerCamelCase )
									    for image in images
									]

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

									A							:					int              =						BatchFeature(
									    data={"flattened_patches": images, "attention_mask": attention_masks}	,	tensor_type=__lowerCamelCase )

									return encoded_outputs




from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Sequence, Value
from .base import TaskTemplate

@dataclass(frozen=_A						)
class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''
						# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
						a__   =  field(default="question-answering-extractive"						,metadata={"include_in_asdict_even_if_is_default": True}						)
						a__   =  Features({"question": Value("string"						), "context": Value("string"						)}						)
						a__   =  Features(
						    {
						        "answers": Sequence(
						            {
						                "text": Value("string"						),
						                "answer_start": Value("int32"						),
						            }						)
						    }						)
						a__   =  "question"
						a__   =  "context"
						a__   =  "answers"







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			Union[str, Any] )      ->				Dict[str, str]:
									return {self.question_column: "question", self.context_column: "context", self.answers_column: "answers"}