




'''simple docstring'''



import unittest

from transformers import is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
      from PIL import Image
else:






      class 							_a				:





             '''simple docstring'''






             @staticmethod
             def        UpperCamelCase_							(      *A,							**A  ):







                   '''simple docstring'''







                   pass






@is_pipeline_test
@require_vision
class 							_a				(			unittest.TestCase ):





       '''simple docstring'''






       @require_torch
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						pipeline(
                 model='hf-internal-testing/tiny-random-clip-zero-shot-image-classification',							)
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						image_classifier(A,							candidate_labels=['a', 'b', 'c']  )

             # The floating scores are so close, we enter floating error approximation and the order is not guaranteed across
             # python and torch versions.
             self.assertIn(
                 nested_simplify(A  ),							[
                     [{'score': 0.3_33, 'label': 'a'}, {'score': 0.3_33, 'label': 'b'}, {'score': 0.3_33, 'label': 'c'}],
                     [{'score': 0.3_33, 'label': 'a'}, {'score': 0.3_33, 'label': 'c'}, {'score': 0.3_33, 'label': 'b'}],
                 ],							)

             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						image_classifier([image] * 5,							candidate_labels=['A', 'B', 'C'],							batch_size=2  )
             self.assertEqual(
                 nested_simplify(A  ),							[
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                 ],							)







       @require_tf
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						pipeline(
                 model='hf-internal-testing/tiny-random-clip-zero-shot-image-classification',							framework='tf'  )
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						image_classifier(A,							candidate_labels=['a', 'b', 'c']  )

             self.assertEqual(
                 nested_simplify(A  ),							[{'score': 0.3_33, 'label': 'a'}, {'score': 0.3_33, 'label': 'b'}, {'score': 0.3_33, 'label': 'c'}],							)

             SCREAMING_SNAKE_CASE   :      Any    					=						image_classifier([image] * 5,							candidate_labels=['A', 'B', 'C'],							batch_size=2  )
             self.assertEqual(
                 nested_simplify(A  ),							[
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                     [
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                         {'score': 0.3_33, 'label': ANY(A  )},
                     ],
                 ],							)







       @slow
       @require_torch
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						pipeline(
                 task='zero-shot-image-classification',							model='openai/clip-vit-base-patch32',							)
             # This is an image of 2 cats with remotes and no planes
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
             SCREAMING_SNAKE_CASE   :      List[str]    					=						image_classifier(A,							candidate_labels=['cat', 'plane', 'remote']  )

             self.assertEqual(
                 nested_simplify(A  ),							[
                     {'score': 0.5_11, 'label': 'remote'},
                     {'score': 0.4_85, 'label': 'cat'},
                     {'score': 0.0_04, 'label': 'plane'},
                 ],							)

             SCREAMING_SNAKE_CASE   :      List[Any]    					=						image_classifier([image] * 5,							candidate_labels=['cat', 'plane', 'remote'],							batch_size=2  )
             self.assertEqual(
                 nested_simplify(A  ),							[
                     [
                         {'score': 0.5_11, 'label': 'remote'},
                         {'score': 0.4_85, 'label': 'cat'},
                         {'score': 0.0_04, 'label': 'plane'},
                     ],
                 ]
                 * 5,							)







       @slow
       @require_tf
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						pipeline(
                 task='zero-shot-image-classification',							model='openai/clip-vit-base-patch32',							framework='tf'  )
             # This is an image of 2 cats with remotes and no planes
             SCREAMING_SNAKE_CASE   :      Tuple    					=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						image_classifier(A,							candidate_labels=['cat', 'plane', 'remote']  )
             self.assertEqual(
                 nested_simplify(A  ),							[
                     {'score': 0.5_11, 'label': 'remote'},
                     {'score': 0.4_85, 'label': 'cat'},
                     {'score': 0.0_04, 'label': 'plane'},
                 ],							)

             SCREAMING_SNAKE_CASE   :      Tuple    					=						image_classifier([image] * 5,							candidate_labels=['cat', 'plane', 'remote'],							batch_size=2  )
             self.assertEqual(
                 nested_simplify(A  ),							[
                     [
                         {'score': 0.5_11, 'label': 'remote'},
                         {'score': 0.4_85, 'label': 'cat'},
                         {'score': 0.0_04, 'label': 'plane'},
                     ],
                 ]
                 * 5,							)




# 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

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase__     :		Tuple        = {
    """configuration_mgp_str""": ["""MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MgpstrConfig"""],
    """processing_mgp_str""": ["""MgpstrProcessor"""],
    """tokenization_mgp_str""": ["""MgpstrTokenizer"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCamelCase__     :		Optional[int]        = [
         """MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """MgpstrModel""",
         """MgpstrPreTrainedModel""",
         """MgpstrForSceneTextRecognition""",
     ]

if TYPE_CHECKING:
     from .configuration_mgp_str import MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP, MgpstrConfig
     from .processing_mgp_str import MgpstrProcessor
     from .tokenization_mgp_str import MgpstrTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_mgp_str import (
              MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST,
              MgpstrForSceneTextRecognition,
              MgpstrModel,
              MgpstrPreTrainedModel,
          )
else:
     import sys

     lowerCamelCase__     :		List[Any]        = _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






