



'''simple docstring'''


import unittest

from transformers import MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING, AutoTokenizer, is_vision_available
from transformers.pipelines import pipeline
from transformers.pipelines.document_question_answering import apply_tesseract
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_detectrona,
    require_pytesseract,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
						from PIL import Image

						from transformers.image_utils import load_image
else:




						class      __UpperCamelCase       :







							@staticmethod
							def   _a   (    *_lowerCAmelCase ,				**_lowerCAmelCase						)    ->    Optional[Any]:
													'''simple docstring'''






													pass







						def      SCREAMING_SNAKE_CASE				(				lowercase_    :      List[Any]						):
												return None


# This is a pinned image from a specific revision of a document question answering space, hosted by HuggingFace,
# so we can expect it to be available.
lowercase_      :				str   					=    (
    '''https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'''
)




@is_pipeline_test
@require_torch
@require_vision
class      __UpperCamelCase       (unittest.TestCase			):
	__A			  =					MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING







	@require_pytesseract
	@require_vision
	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    Dict:
							'''simple docstring'''






							lowercase        =							pipeline(
							    """document-question-answering""" ,				model=_lowerCAmelCase ,				tokenizer=_lowerCAmelCase ,				image_processor=_lowerCAmelCase						)

							lowercase        =							INVOICE_URL
							lowercase        =							list(zip(*apply_tesseract(load_image(_lowerCAmelCase						) ,				_lowerCAmelCase ,				""""""						)						)						)
							lowercase        =							"""What is the placebo?"""
							lowercase        =							[
							    {
							        """image""": load_image(_lowerCAmelCase						),
							        """question""": question,
							    },
							    {
							        """image""": image,
							        """question""": question,
							    },
							    {
							        """image""": image,
							        """question""": question,
							        """word_boxes""": word_boxes,
							    },
							]
							return dqa_pipeline, examples







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    List[Any]:
							'''simple docstring'''






							lowercase        =							dqa_pipeline(_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(
							    _lowerCAmelCase ,				[
							        [
							            {"""score""": ANY(_lowerCAmelCase						), """answer""": ANY(_lowerCAmelCase						), """start""": ANY(_lowerCAmelCase						), """end""": ANY(_lowerCAmelCase						)},
							            {"""score""": ANY(_lowerCAmelCase						), """answer""": ANY(_lowerCAmelCase						), """start""": ANY(_lowerCAmelCase						), """end""": ANY(_lowerCAmelCase						)},
							        ]
							    ]
							    * 3 ,				)







	@require_torch
	@require_detectrona
	@require_pytesseract
	def   _a   (    self						)    ->    str:
							'''simple docstring'''






							lowercase        =							pipeline("""document-question-answering""" ,				model="""hf-internal-testing/tiny-random-layoutlmv2"""						)
							lowercase        =							INVOICE_URL
							lowercase        =							"""How many cats are there?"""

							lowercase        =							[
							    {"""score""": 0.0001, """answer""": """oy 2312/2019""", """start""": 38, """end""": 39},
							    {"""score""": 0.0001, """answer""": """oy 2312/2019 DUE""", """start""": 38, """end""": 40},
							]
							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				_lowerCAmelCase						)

							lowercase        =							dqa_pipeline({"""image""": image, """question""": question} ,				top_k=2						)
							self.assertEqual(nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				_lowerCAmelCase						)

							# This image does not detect ANY text in it, meaning layoutlmv2 should fail.
							# Empty answer probably
							lowercase        =							"""./tests/fixtures/tests_samples/COCO/000000039769.png"""
							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(_lowerCAmelCase ,				[]						)

							# We can optionnally pass directly the words and bounding boxes
							lowercase        =							"""./tests/fixtures/tests_samples/COCO/000000039769.png"""
							lowercase        =							[]
							lowercase        =							[]
							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				words=_lowerCAmelCase ,				boxes=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(_lowerCAmelCase ,				[]						)







	@slow
	@require_torch
	@require_detectrona
	@require_pytesseract
	def   _a   (    self						)    ->    str:
							'''simple docstring'''






							lowercase        =							pipeline(
							    """document-question-answering""" ,				model="""tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa""" ,				revision="""9977165""" ,				)
							lowercase        =							INVOICE_URL
							lowercase        =							"""What is the invoice number?"""

							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.9944, """answer""": """us-001""", """start""": 16, """end""": 16},
							        {"""score""": 0.0009, """answer""": """us-001""", """start""": 16, """end""": 16},
							    ] ,				)

							lowercase        =							dqa_pipeline({"""image""": image, """question""": question} ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.9944, """answer""": """us-001""", """start""": 16, """end""": 16},
							        {"""score""": 0.0009, """answer""": """us-001""", """start""": 16, """end""": 16},
							    ] ,				)

							lowercase        =							dqa_pipeline(
							    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}] ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        [
							            {"""score""": 0.9944, """answer""": """us-001""", """start""": 16, """end""": 16},
							            {"""score""": 0.0009, """answer""": """us-001""", """start""": 16, """end""": 16},
							        ],
							    ]
							    * 2 ,				)







	@slow
	@require_torch
	@require_detectrona
	@require_pytesseract
	def   _a   (    self						)    ->    Dict:
							'''simple docstring'''






							lowercase        =							pipeline(
							    """document-question-answering""" ,				model="""tiennvcs/layoutlmv2-base-uncased-finetuned-docvqa""" ,				revision="""9977165""" ,				max_seq_len=50 ,				)
							lowercase        =							INVOICE_URL
							lowercase        =							"""What is the invoice number?"""

							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.9974, """answer""": """1110212019""", """start""": 23, """end""": 23},
							        {"""score""": 0.9948, """answer""": """us-001""", """start""": 16, """end""": 16},
							    ] ,				)

							lowercase        =							dqa_pipeline({"""image""": image, """question""": question} ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.9974, """answer""": """1110212019""", """start""": 23, """end""": 23},
							        {"""score""": 0.9948, """answer""": """us-001""", """start""": 16, """end""": 16},
							    ] ,				)

							lowercase        =							dqa_pipeline(
							    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}] ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        [
							            {"""score""": 0.9974, """answer""": """1110212019""", """start""": 23, """end""": 23},
							            {"""score""": 0.9948, """answer""": """us-001""", """start""": 16, """end""": 16},
							        ]
							    ]
							    * 2 ,				)







	@slow
	@require_torch
	@require_pytesseract
	@require_vision
	def   _a   (    self						)    ->    Optional[Any]:
							'''simple docstring'''






							lowercase        =							AutoTokenizer.from_pretrained(
							    """impira/layoutlm-document-qa""" ,				revision="""3dc6de3""" ,				add_prefix_space=_lowerCAmelCase						)
							lowercase        =							pipeline(
							    """document-question-answering""" ,				model="""impira/layoutlm-document-qa""" ,				tokenizer=_lowerCAmelCase ,				revision="""3dc6de3""" ,				)
							lowercase        =							INVOICE_URL
							lowercase        =							"""What is the invoice number?"""

							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
							        {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
							    ] ,				)

							lowercase        =							dqa_pipeline({"""image""": image, """question""": question} ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
							        {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
							    ] ,				)

							lowercase        =							dqa_pipeline(
							    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}] ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        [
							            {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
							            {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
							        ]
							    ]
							    * 2 ,				)

							lowercase        =							list(zip(*apply_tesseract(load_image(_lowerCAmelCase						) ,				_lowerCAmelCase ,				""""""						)						)						)

							# This model should also work if `image` is set to None
							lowercase        =							dqa_pipeline({"""image""": None, """word_boxes""": word_boxes, """question""": question} ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.4251, """answer""": """us-001""", """start""": 16, """end""": 16},
							        {"""score""": 0.0819, """answer""": """1110212019""", """start""": 23, """end""": 23},
							    ] ,				)







	@slow
	@require_torch
	@require_pytesseract
	@require_vision
	def   _a   (    self						)    ->    Any:
							'''simple docstring'''






							lowercase        =							AutoTokenizer.from_pretrained(
							    """impira/layoutlm-document-qa""" ,				revision="""3dc6de3""" ,				add_prefix_space=_lowerCAmelCase						)
							lowercase        =							pipeline(
							    """document-question-answering""" ,				model="""impira/layoutlm-document-qa""" ,				tokenizer=_lowerCAmelCase ,				revision="""3dc6de3""" ,				max_seq_len=50 ,				)
							lowercase        =							INVOICE_URL
							lowercase        =							"""What is the invoice number?"""

							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.9999, """answer""": """us-001""", """start""": 16, """end""": 16},
							        {"""score""": 0.9998, """answer""": """us-001""", """start""": 16, """end""": 16},
							    ] ,				)

							lowercase        =							dqa_pipeline(
							    [{"""image""": image, """question""": question}, {"""image""": image, """question""": question}] ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        [
							            {"""score""": 0.9999, """answer""": """us-001""", """start""": 16, """end""": 16},
							            {"""score""": 0.9998, """answer""": """us-001""", """start""": 16, """end""": 16},
							        ]
							    ]
							    * 2 ,				)

							lowercase        =							list(zip(*apply_tesseract(load_image(_lowerCAmelCase						) ,				_lowerCAmelCase ,				""""""						)						)						)

							# This model should also work if `image` is set to None
							lowercase        =							dqa_pipeline({"""image""": None, """word_boxes""": word_boxes, """question""": question} ,				top_k=2						)
							self.assertEqual(
							    nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[
							        {"""score""": 0.9999, """answer""": """us-001""", """start""": 16, """end""": 16},
							        {"""score""": 0.9998, """answer""": """us-001""", """start""": 16, """end""": 16},
							    ] ,				)







	@slow
	@require_torch
	def   _a   (    self						)    ->    str:
							'''simple docstring'''






							lowercase        =							pipeline(
							    """document-question-answering""" ,				model="""naver-clova-ix/donut-base-finetuned-docvqa""" ,				tokenizer=AutoTokenizer.from_pretrained("""naver-clova-ix/donut-base-finetuned-docvqa"""						) ,				feature_extractor="""naver-clova-ix/donut-base-finetuned-docvqa""" ,				)

							lowercase        =							INVOICE_URL
							lowercase        =							"""What is the invoice number?"""
							lowercase        =							dqa_pipeline(image=_lowerCAmelCase ,				question=_lowerCAmelCase ,				top_k=2						)
							self.assertEqual(nested_simplify(_lowerCAmelCase ,				decimals=4						) ,				[{"""answer""": """us-001"""}]						)







	@require_tf
	@unittest.skip("""Document question answering not implemented in TF"""						)
	def   _a   (    self						)    ->    Dict:
							'''simple docstring'''






							pass







'''simple docstring'''


import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


lowercase_      :				Optional[Any]   					=    logging.get_logger(__name__)

lowercase_      :				int   					=    {'''vocab_file''': '''spm_char.model'''}

lowercase_      :				int   					=    {
    '''vocab_file''': {
        '''microsoft/speecht5_asr''': '''https://huggingface.co/microsoft/speecht5_asr/resolve/main/spm_char.model''',
        '''microsoft/speecht5_tts''': '''https://huggingface.co/microsoft/speecht5_tts/resolve/main/spm_char.model''',
        '''microsoft/speecht5_vc''': '''https://huggingface.co/microsoft/speecht5_vc/resolve/main/spm_char.model''',
    }
}

lowercase_      :				Optional[Any]   					=    {
    '''microsoft/speecht5_asr''': 1024,
    '''microsoft/speecht5_tts''': 1024,
    '''microsoft/speecht5_vc''': 1024,
}




class      __UpperCamelCase       (_UpperCAmelCase			):
	__A			  =					VOCAB_FILES_NAMES
	__A			  =					PRETRAINED_VOCAB_FILES_MAP
	__A			  =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	__A			  =					['''input_ids''', '''attention_mask''']







	def __init__(    self ,				_lowerCAmelCase ,				_lowerCAmelCase="<s>" ,				_lowerCAmelCase="</s>" ,				_lowerCAmelCase="<unk>" ,				_lowerCAmelCase="<pad>" ,				_lowerCAmelCase = None ,				**_lowerCAmelCase ,				)    ->    None:
							'''simple docstring'''






							lowercase        =							{} if sp_model_kwargs is None else sp_model_kwargs

							super().__init__(
							    bos_token=_lowerCAmelCase ,				eos_token=_lowerCAmelCase ,				unk_token=_lowerCAmelCase ,				pad_token=_lowerCAmelCase ,				sp_model_kwargs=self.sp_model_kwargs ,				**_lowerCAmelCase ,				)

							lowercase        =							vocab_file

							lowercase        =							spm.SentencePieceProcessor(**self.sp_model_kwargs						)
							self.sp_model.Load(_lowerCAmelCase						)







	@property
	def   _a   (    self						)    ->    List[Any]:
							'''simple docstring'''






							return self.sp_model.get_piece_size()







	def   _a   (    self						)    ->    str:
							'''simple docstring'''






							lowercase        =							{self.convert_ids_to_tokens(_lowerCAmelCase						): i for i in range(self.vocab_size						)}
							vocab.update(self.added_tokens_encoder						)
							return vocab







	def __getstate__(    self						)    ->    Union[str, Any]:
							'''simple docstring'''






							lowercase        =							self.__dict__.copy()
							lowercase        =							None
							return state







	def __setstate__(    self ,				_lowerCAmelCase						)    ->    Optional[int]:
							'''simple docstring'''






							lowercase        =							d

							# for backward compatibility
							if not hasattr(self ,				"""sp_model_kwargs"""						):
													lowercase        =							{}

							lowercase        =							spm.SentencePieceProcessor(**self.sp_model_kwargs						)
							self.sp_model.Load(self.vocab_file						)







	def   _a   (    self ,				_lowerCAmelCase						)    ->    List[str]:
							'''simple docstring'''






							return self.sp_model.encode(_lowerCAmelCase ,				out_type=_lowerCAmelCase						)







	def   _a   (    self ,				_lowerCAmelCase						)    ->    List[Any]:
							'''simple docstring'''






							return self.sp_model.piece_to_id(_lowerCAmelCase						)







	def   _a   (    self ,				_lowerCAmelCase						)    ->    str:
							'''simple docstring'''






							lowercase        =							self.sp_model.IdToPiece(_lowerCAmelCase						)
							return token







	def   _a   (    self ,				_lowerCAmelCase						)    ->    Optional[Any]:
							'''simple docstring'''






							lowercase        =							[]
							lowercase        =							""""""
							for token in tokens:
													# make sure that special tokens are not decoded using sentencepiece model
													if token in self.all_special_tokens:
																			out_string += self.sp_model.decode(_lowerCAmelCase						) + token
																			lowercase        =							[]
													else:
																			current_sub_tokens.append(_lowerCAmelCase						)
							out_string += self.sp_model.decode(_lowerCAmelCase						)
							return out_string.strip()







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase=None						)    ->    List[int]:
							'''simple docstring'''






							if token_ids_a is None:
													return token_ids_a + [self.eos_token_id]
							# We don't expect to process pairs, but leave the pair logic for API consistency
							return token_ids_a + token_ids_a + [self.eos_token_id]







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase = None ,				_lowerCAmelCase = False						)    ->    List[int]:
							'''simple docstring'''






							if already_has_special_tokens:
													return super().get_special_tokens_mask(
													    token_ids_a=_lowerCAmelCase ,				token_ids_a=_lowerCAmelCase ,				already_has_special_tokens=_lowerCAmelCase						)

							lowercase        =							[1]
							if token_ids_a is None:
													return ([0] * len(_lowerCAmelCase						)) + suffix_ones
							return ([0] * len(_lowerCAmelCase						)) + ([0] * len(_lowerCAmelCase						)) + suffix_ones







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase = None						)    ->    Tuple[str]:
							'''simple docstring'''






							if not os.path.isdir(_lowerCAmelCase						):
													logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""						)
													return
							lowercase        =							os.path.join(
							    _lowerCAmelCase ,				(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]						)

							if os.path.abspath(self.vocab_file						) != os.path.abspath(_lowerCAmelCase						) and os.path.isfile(self.vocab_file						):
													copyfile(self.vocab_file ,				_lowerCAmelCase						)
							elif not os.path.isfile(self.vocab_file						):
													with open(_lowerCAmelCase ,				"""wb"""						) as fi:
																			lowercase        =							self.sp_model.serialized_model_proto()
																			fi.write(_lowerCAmelCase						)

							return (out_vocab_file,)


