
'''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 			SCREAMING_SNAKE_CASE__      :







										@staticmethod
										def 						UpperCAmelCase_    (       *A_						,				**A_     )->		int:







																	'''simple docstring'''






																	pass







						def 		A_(     A						:		List[str]):
													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.
lowerCAmelCase					:    int           = (
    'https://huggingface.co/spaces/impira/docquery/resolve/2f6c96314dc84dfda62d40de9da55f2f5165d403/invoice.png'
)


@is_pipeline_test
@require_torch
@require_vision
class 			SCREAMING_SNAKE_CASE__      (     unittest.TestCase):
				lowerCAmelCase_     			=							MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING







				@require_pytesseract
				@require_vision
				def 						UpperCAmelCase_    (       self						,				A_						,				A_						,				A_     )->		Optional[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     pipeline(
											    'document-question-answering'						,				model=A_						,				tokenizer=A_						,				image_processor=A_     )

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







				def 						UpperCAmelCase_    (       self						,				A_						,				A_     )->		Any:







											'''simple docstring'''






											UpperCamelCase   			=     dqa_pipeline(A_						,				top_k=2     )
											self.assertEqual(
											    A_						,				[
											        [
											            {'score': ANY(A_     ), 'answer': ANY(A_     ), 'start': ANY(A_     ), 'end': ANY(A_     )},
											            {'score': ANY(A_     ), 'answer': ANY(A_     ), 'start': ANY(A_     ), 'end': ANY(A_     )},
											        ]
											    ]
											    * 3						,				)







				@require_torch
				@require_detectrona
				@require_pytesseract
				def 						UpperCAmelCase_    (       self     )->		Optional[int]:







											'''simple docstring'''






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

											UpperCamelCase   			=     [
											    {'score': 0.0_001, 'answer': 'oy 2312/2019', 'start': 38, 'end': 39},
											    {'score': 0.0_001, 'answer': 'oy 2312/2019 DUE', 'start': 38, 'end': 40},
											]
											UpperCamelCase   			=     dqa_pipeline(image=A_						,				question=A_						,				top_k=2     )
											self.assertEqual(nested_simplify(A_						,				decimals=4     )						,				A_     )

											UpperCamelCase   			=     dqa_pipeline({'image': image, 'question': question}						,				top_k=2     )
											self.assertEqual(nested_simplify(A_						,				decimals=4     )						,				A_     )

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

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







				@slow
				@require_torch
				@require_detectrona
				@require_pytesseract
				def 						UpperCAmelCase_    (       self     )->		Tuple:







											'''simple docstring'''






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

											UpperCamelCase   			=     dqa_pipeline(image=A_						,				question=A_						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.9_944, 'answer': 'us-001', 'start': 16, 'end': 16},
											        {'score': 0.0_009, 'answer': 'us-001', 'start': 16, 'end': 16},
											    ]						,				)

											UpperCamelCase   			=     dqa_pipeline({'image': image, 'question': question}						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.9_944, 'answer': 'us-001', 'start': 16, 'end': 16},
											        {'score': 0.0_009, 'answer': 'us-001', 'start': 16, 'end': 16},
											    ]						,				)

											UpperCamelCase   			=     dqa_pipeline(
											    [{'image': image, 'question': question}, {'image': image, 'question': question}]						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        [
											            {'score': 0.9_944, 'answer': 'us-001', 'start': 16, 'end': 16},
											            {'score': 0.0_009, 'answer': 'us-001', 'start': 16, 'end': 16},
											        ],
											    ]
											    * 2						,				)







				@slow
				@require_torch
				@require_detectrona
				@require_pytesseract
				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






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

											UpperCamelCase   			=     dqa_pipeline(image=A_						,				question=A_						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.9_974, 'answer': '1110212019', 'start': 23, 'end': 23},
											        {'score': 0.9_948, 'answer': 'us-001', 'start': 16, 'end': 16},
											    ]						,				)

											UpperCamelCase   			=     dqa_pipeline({'image': image, 'question': question}						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.9_974, 'answer': '1110212019', 'start': 23, 'end': 23},
											        {'score': 0.9_948, 'answer': 'us-001', 'start': 16, 'end': 16},
											    ]						,				)

											UpperCamelCase   			=     dqa_pipeline(
											    [{'image': image, 'question': question}, {'image': image, 'question': question}]						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        [
											            {'score': 0.9_974, 'answer': '1110212019', 'start': 23, 'end': 23},
											            {'score': 0.9_948, 'answer': 'us-001', 'start': 16, 'end': 16},
											        ]
											    ]
											    * 2						,				)







				@slow
				@require_torch
				@require_pytesseract
				@require_vision
				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






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

											UpperCamelCase   			=     dqa_pipeline(image=A_						,				question=A_						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.4_251, 'answer': 'us-001', 'start': 16, 'end': 16},
											        {'score': 0.0_819, 'answer': '1110212019', 'start': 23, 'end': 23},
											    ]						,				)

											UpperCamelCase   			=     dqa_pipeline({'image': image, 'question': question}						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.4_251, 'answer': 'us-001', 'start': 16, 'end': 16},
											        {'score': 0.0_819, 'answer': '1110212019', 'start': 23, 'end': 23},
											    ]						,				)

											UpperCamelCase   			=     dqa_pipeline(
											    [{'image': image, 'question': question}, {'image': image, 'question': question}]						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        [
											            {'score': 0.4_251, 'answer': 'us-001', 'start': 16, 'end': 16},
											            {'score': 0.0_819, 'answer': '1110212019', 'start': 23, 'end': 23},
											        ]
											    ]
											    * 2						,				)

											UpperCamelCase   			=     list(zip(*apply_tesseract(load_image(A_     )						,				A_						,				''     )     )     )

											# This model should also work if `image` is set to None
											UpperCamelCase   			=     dqa_pipeline({'image': None, 'word_boxes': word_boxes, 'question': question}						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.4_251, 'answer': 'us-001', 'start': 16, 'end': 16},
											        {'score': 0.0_819, 'answer': '1110212019', 'start': 23, 'end': 23},
											    ]						,				)







				@slow
				@require_torch
				@require_pytesseract
				@require_vision
				def 						UpperCAmelCase_    (       self     )->		List[str]:







											'''simple docstring'''






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

											UpperCamelCase   			=     dqa_pipeline(image=A_						,				question=A_						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.9_999, 'answer': 'us-001', 'start': 16, 'end': 16},
											        {'score': 0.9_998, 'answer': 'us-001', 'start': 16, 'end': 16},
											    ]						,				)

											UpperCamelCase   			=     dqa_pipeline(
											    [{'image': image, 'question': question}, {'image': image, 'question': question}]						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        [
											            {'score': 0.9_999, 'answer': 'us-001', 'start': 16, 'end': 16},
											            {'score': 0.9_998, 'answer': 'us-001', 'start': 16, 'end': 16},
											        ]
											    ]
											    * 2						,				)

											UpperCamelCase   			=     list(zip(*apply_tesseract(load_image(A_     )						,				A_						,				''     )     )     )

											# This model should also work if `image` is set to None
											UpperCamelCase   			=     dqa_pipeline({'image': None, 'word_boxes': word_boxes, 'question': question}						,				top_k=2     )
											self.assertEqual(
											    nested_simplify(A_						,				decimals=4     )						,				[
											        {'score': 0.9_999, 'answer': 'us-001', 'start': 16, 'end': 16},
											        {'score': 0.9_998, 'answer': 'us-001', 'start': 16, 'end': 16},
											    ]						,				)







				@slow
				@require_torch
				def 						UpperCAmelCase_    (       self     )->		Union[str, Any]:







											'''simple docstring'''






											UpperCamelCase   			=     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'						,				)

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







				@require_tf
				@unittest.skip('Document question answering not implemented in TF'     )
				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											pass





'''simple docstring'''




# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__UpperCAmelCase					={
    "configuration_efficientnet": [
        "EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "EfficientNetConfig",
        "EfficientNetOnnxConfig",
    ]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase					=["EfficientNetImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase					=[
      "EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST",
      "EfficientNetForImageClassification",
      "EfficientNetModel",
      "EfficientNetPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_efficientnet import (
      EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
      EfficientNetConfig,
      EfficientNetOnnxConfig,
  )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_efficientnet import EfficientNetImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_efficientnet import (
        EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
        EfficientNetForImageClassification,
        EfficientNetModel,
        EfficientNetPreTrainedModel,
    )

else:
  import sys

  __UpperCAmelCase					=_LazyModule(__name__, globals()["__file__"], _import_structure)
