



"""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:
			UpperCamelCase     =							False


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

def       _lowerCamelCase				(							)	-> 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       _lowerCamelCase				(							UpperCAmelCase_ :       str,	UpperCAmelCase_ :       Any,	UpperCAmelCase_ :       Dict     )	-> Optional[int]:






	"""simple docstring"""





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

	A__											=					image_tensor.unsqueeze(0     )
	A__											=					torch.nn.functional.unfold(UpperCAmelCase_,	(patch_height, patch_width),	stride=(patch_height, patch_width)     )
	A__											=					patches.reshape(image_tensor.size(0     ),	image_tensor.size(1     ),	UpperCAmelCase_,	UpperCAmelCase_,	-1     )
	A__											=					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       _lowerCamelCase				(							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.

	A__											=					textwrap.TextWrapper(width=80     )
	A__											=					wrapper.wrap(text=UpperCAmelCase_     )
	A__											=					"\n".join(UpperCAmelCase_     )

	if font_bytes is not None and font_path is None:
		A__											=					io.BytesIO(UpperCAmelCase_     )
	elif font_path is not None:
		A__											=					font_path
	else:
		A__											=					hf_hub_download(UpperCAmelCase_,	"Arial.TTF"     )
	A__											=					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__											=					ImageDraw.Draw(Image.new("RGB",	(1, 1),	UpperCAmelCase_     )     )
	A__							,							A__							,							A__							,							A__											=					temp_draw.textbbox((0, 0),	UpperCAmelCase_,	UpperCAmelCase_     )

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

def       _lowerCamelCase				(							UpperCAmelCase_ :       np.ndarray,	UpperCAmelCase_ :       str,	**UpperCAmelCase_ :       Dict     )	-> Optional[Any]:






	"""simple docstring"""





	requires_backends(UpperCAmelCase_,	"vision"     )

	# Convert to PIL image if necessary
	A__											=					to_pil_image(UpperCAmelCase_     )

	A__											=					render_text(UpperCAmelCase_,	**UpperCAmelCase_     )
	A__											=					max(header_image.width,	image.width     )

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

	A__											=					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__											=					to_numpy_array(UpperCAmelCase_     )

	if infer_channel_dimension_format(UpperCAmelCase_     ) == ChannelDimension.LAST:
		A__											=					to_channel_dimension_format(UpperCAmelCase_,	ChannelDimension.LAST     )

	return new_image






class       UpperCamelCase__			(   _lowerCAmelCase      ):

			"""simple docstring"""


			A__	:					int							  =     ["flattened_patches"]


			def __init__(      self						,	SCREAMING_SNAKE_CASE__ = True						,	SCREAMING_SNAKE_CASE__ = True						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = 2048						,	SCREAMING_SNAKE_CASE__ = False						,	**SCREAMING_SNAKE_CASE__						,	)      ->	None:
				super().__init__(**SCREAMING_SNAKE_CASE__		)
				A__											=					patch_size if patch_size is not None else {"height": 16, "width": 16}
				A__											=					do_normalize
				A__											=					do_convert_rgb
				A__											=					max_patches
				A__											=					is_vqa


			def   snake_case__	(      self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	**SCREAMING_SNAKE_CASE__		)      ->	np.ndarray:
				requires_backends(self.extract_flattened_patches						,	"torch"		)
				_check_torch_version()

				# convert to torch
				A__											=					to_channel_dimension_format(SCREAMING_SNAKE_CASE__						,	ChannelDimension.FIRST		)
				A__											=					torch.from_numpy(SCREAMING_SNAKE_CASE__		)

				A__							,							A__											=					patch_size["height"], patch_size["width"]
				A__							,							A__											=					get_image_size(SCREAMING_SNAKE_CASE__		)

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

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

				# [1, rows, columns, patch_height * patch_width * image_channels]
				A__											=					torch_extract_patches(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__		)

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

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

				# [rows * columns, 1]
				A__											=					torch.arange(SCREAMING_SNAKE_CASE__		).reshape([rows, 1]		).repeat(1						,	SCREAMING_SNAKE_CASE__		).reshape([rows * columns, 1]		)
				A__											=					torch.arange(SCREAMING_SNAKE_CASE__		).reshape([1, columns]		).repeat(SCREAMING_SNAKE_CASE__						,	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__											=					row_ids.to(torch.floataa		)
				A__											=					col_ids.to(torch.floataa		)

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

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

				A__											=					to_numpy_array(SCREAMING_SNAKE_CASE__		)

				return result


			def   snake_case__	(      self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None						,	**SCREAMING_SNAKE_CASE__		)      ->	np.ndarray:
				if image.dtype == np.uinta:
					A__											=					image.astype(np.floataa		)

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

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







			def   snake_case__	(      self						,	SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = None						,	SCREAMING_SNAKE_CASE__ = ChannelDimension.FIRST						,	**SCREAMING_SNAKE_CASE__						,	)      ->	ImageInput:
				A__											=					do_normalize if do_normalize is not None else self.do_normalize
				A__											=					do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb
				A__											=					patch_size if patch_size is not None else self.patch_size
				A__											=					max_patches if max_patches is not None else self.max_patches
				A__											=					self.is_vqa

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

				A__											=					make_list_of_images(SCREAMING_SNAKE_CASE__		)

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

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

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

					if isinstance(SCREAMING_SNAKE_CASE__						,	SCREAMING_SNAKE_CASE__		):
						A__											=					[header_text] * len(SCREAMING_SNAKE_CASE__		)

					A__											=					[
					    render_header(SCREAMING_SNAKE_CASE__						,	header_text[i]						,	font_bytes=SCREAMING_SNAKE_CASE__						,	font_path=SCREAMING_SNAKE_CASE__		)
					    for i, image in enumerate(SCREAMING_SNAKE_CASE__		)
					]

				if do_normalize:
					A__											=					[self.normalize(image=SCREAMING_SNAKE_CASE__		) for image in images]

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

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

				A__											=					BatchFeature(
				    data={"flattened_patches": images, "attention_mask": attention_masks}						,	tensor_type=SCREAMING_SNAKE_CASE__		)

				return encoded_outputs









import itertools
from dataclasses import dataclass
from typing import Any, Callable, Dict, List, Optional, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast
from datasets.utils.py_utils import Literal


_lowerCAmelCase	:   Any    =   datasets.utils.logging.get_logger(__name__)

_lowerCAmelCase	:   Any    =   ["names", "prefix"]
_lowerCAmelCase	:   str    =   ["warn_bad_lines", "error_bad_lines", "mangle_dupe_cols"]
_lowerCAmelCase	:   List[str]    =   ["encoding_errors", "on_bad_lines"]
_lowerCAmelCase	:   int    =   ["date_format"]


@dataclass
class 	__snake_case   ( datasets.BuilderConfig ):
		SCREAMING_SNAKE_CASE__								=	","
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	"infer"
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	True
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	False
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	True
		SCREAMING_SNAKE_CASE__								=	True
		SCREAMING_SNAKE_CASE__								=	False
		SCREAMING_SNAKE_CASE__								=	True
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	"."
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	'"'
		SCREAMING_SNAKE_CASE__								=	0
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	True
		SCREAMING_SNAKE_CASE__								=	True
		SCREAMING_SNAKE_CASE__								=	0
		SCREAMING_SNAKE_CASE__								=	True
		SCREAMING_SNAKE_CASE__								=	False
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	10000
		SCREAMING_SNAKE_CASE__								=	None
		SCREAMING_SNAKE_CASE__								=	"strict"
		SCREAMING_SNAKE_CASE__								=	"error"
		SCREAMING_SNAKE_CASE__								=	None
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						if self.delimiter is not None:
										lowerCAmelCase__		  =  self.delimiter
						if self.column_names is not None:
										lowerCAmelCase__		  =  self.column_names



		@property
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						lowerCAmelCase__		  =  {
						    'sep': self.sep,
						    'header': self.header,
						    'names': self.names,
						    'index_col': self.index_col,
						    'usecols': self.usecols,
						    'prefix': self.prefix,
						    'mangle_dupe_cols': self.mangle_dupe_cols,
						    'engine': self.engine,
						    'converters': self.converters,
						    'true_values': self.true_values,
						    'false_values': self.false_values,
						    'skipinitialspace': self.skipinitialspace,
						    'skiprows': self.skiprows,
						    'nrows': self.nrows,
						    'na_values': self.na_values,
						    'keep_default_na': self.keep_default_na,
						    'na_filter': self.na_filter,
						    'verbose': self.verbose,
						    'skip_blank_lines': self.skip_blank_lines,
						    'thousands': self.thousands,
						    'decimal': self.decimal,
						    'lineterminator': self.lineterminator,
						    'quotechar': self.quotechar,
						    'quoting': self.quoting,
						    'escapechar': self.escapechar,
						    'comment': self.comment,
						    'encoding': self.encoding,
						    'dialect': self.dialect,
						    'error_bad_lines': self.error_bad_lines,
						    'warn_bad_lines': self.warn_bad_lines,
						    'skipfooter': self.skipfooter,
						    'doublequote': self.doublequote,
						    'memory_map': self.memory_map,
						    'float_precision': self.float_precision,
						    'chunksize': self.chunksize,
						    'encoding_errors': self.encoding_errors,
						    'on_bad_lines': self.on_bad_lines,
						    'date_format': self.date_format,
						}

						# some kwargs must not be passed if they don't have a default value
						# some others are deprecated and we can also not pass them if they are the default value
						for pd_read_csv_parameter in _PANDAS_READ_CSV_NO_DEFAULT_PARAMETERS + _PANDAS_READ_CSV_DEPRECATED_PARAMETERS:
										if pd_read_csv_kwargs[pd_read_csv_parameter] == getattr(CsvConfig()    ,a_						):
														del pd_read_csv_kwargs[pd_read_csv_parameter]

        # Remove 2.0 new arguments
						if not (datasets.config.PANDAS_VERSION.major >= 2):
										for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_2_0_0_PARAMETERS:
														del pd_read_csv_kwargs[pd_read_csv_parameter]

        # Remove 1.3 new arguments
						if not (datasets.config.PANDAS_VERSION.major >= 1 and datasets.config.PANDAS_VERSION.minor >= 3):
										for pd_read_csv_parameter in _PANDAS_READ_CSV_NEW_1_3_0_PARAMETERS:
														del pd_read_csv_kwargs[pd_read_csv_parameter]

						return pd_read_csv_kwargs



class 	__snake_case   ( datasets.ArrowBasedBuilder ):
		SCREAMING_SNAKE_CASE__								=	CsvConfig
		def 						SCREAMING_SNAKE_CASE_					(							self						):







						"""simple docstring"""
						return datasets.DatasetInfo(features=self.config.features						)
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						if not self.config.data_files:
										raise ValueError(f'At least one data file must be specified, but got data_files={self.config.data_files}'						)
						lowerCAmelCase__		  =  dl_manager.download_and_extract(self.config.data_files						)
						if isinstance(a_    ,(str, list, tuple)						):
										lowerCAmelCase__		  =  data_files
										if isinstance(a_    ,a_						):
														lowerCAmelCase__		  =  [files]
										lowerCAmelCase__		  =  [dl_manager.iter_files(a_						) for file in files]
										return [datasets.SplitGenerator(name=datasets.Split.TRAIN    ,gen_kwargs={'files': files}						)]
						lowerCAmelCase__		  =  []
						for split_name, files in data_files.items():
										if isinstance(a_    ,a_						):
														lowerCAmelCase__		  =  [files]
										lowerCAmelCase__		  =  [dl_manager.iter_files(a_						) for file in files]
										splits.append(datasets.SplitGenerator(name=a_    ,gen_kwargs={'files': files}						)						)
						return splits
		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						if self.config.features is not None:
										lowerCAmelCase__		  =  self.config.features.arrow_schema
										if all(not require_storage_cast(a_						) for feature in self.config.features.values()						):
														# cheaper cast
														lowerCAmelCase__		  =  pa.Table.from_arrays([pa_table[field.name] for field in schema]    ,schema=a_						)
										else:
														# more expensive cast; allows str <-> int/float or str to Audio for example
														lowerCAmelCase__		  =  table_cast(a_    ,a_						)
						return pa_table



		def 						SCREAMING_SNAKE_CASE_					(							self    ,a_						):







						"""simple docstring"""
						lowerCAmelCase__		  =  self.config.features.arrow_schema if self.config.features else None
						# dtype allows reading an int column as str
						lowerCAmelCase__		  =  (
						    {
						        name: dtype.to_pandas_dtype() if not require_storage_cast(a_						) else object
						        for name, dtype, feature in zip(schema.names    ,schema.types    ,self.config.features.values()						)
						    }
						    if schema is not None
						    else None
						)
						for file_idx, file in enumerate(itertools.chain.from_iterable(a_						)						):
										lowerCAmelCase__		  =  pd.read_csv(a_    ,iterator=a_    ,dtype=a_    ,**self.config.pd_read_csv_kwargs						)
										try:
														for batch_idx, df in enumerate(a_						):
																		lowerCAmelCase__		  =  pa.Table.from_pandas(a_						)
																		# Uncomment for debugging (will print the Arrow table size and elements)
																		# logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
																		# logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
																		yield (file_idx, batch_idx), self._cast_table(a_						)
										except ValueError as e:
														logger.error(f'Failed to read file \'{file}\' with error {type(a_						)}: {e}'						)
														raise
