




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     lowerCamelCase__:
             @staticmethod
             def 			lowerCAmelCase__						(				*UpperCamelCase_: int    ,       **UpperCamelCase_: List[str]   ):
                    pass





@is_pipeline_test
@require_vision
class     lowerCamelCase__(					unittest.TestCase):
      @require_torch
      def 			lowerCAmelCase__						(				self: Any   ):
             __lowerCamelCase   =						pipeline(
                 model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""    ,       )
             __lowerCamelCase   =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
             __lowerCamelCase   =						image_classifier(UpperCamelCase_    ,       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(UpperCamelCase_   )    ,       [
                     [{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """b"""}, {"""score""": 0.333, """label""": """c"""}],
                     [{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """c"""}, {"""score""": 0.333, """label""": """b"""}],
                 ]    ,       )

             __lowerCamelCase   =						image_classifier([image] * 5    ,       candidate_labels=["""A""", """B""", """C"""]    ,       batch_size=2   )
             self.assertEqual(
                 nested_simplify(UpperCamelCase_   )    ,       [
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                 ]    ,       )
      @require_tf
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             __lowerCamelCase   =						pipeline(
                 model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""    ,       framework="""tf"""   )
             __lowerCamelCase   =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
             __lowerCamelCase   =						image_classifier(UpperCamelCase_    ,       candidate_labels=["""a""", """b""", """c"""]   )

             self.assertEqual(
                 nested_simplify(UpperCamelCase_   )    ,       [{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """b"""}, {"""score""": 0.333, """label""": """c"""}]    ,       )

             __lowerCamelCase   =						image_classifier([image] * 5    ,       candidate_labels=["""A""", """B""", """C"""]    ,       batch_size=2   )
             self.assertEqual(
                 nested_simplify(UpperCamelCase_   )    ,       [
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                     [
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                         {"""score""": 0.333, """label""": ANY(UpperCamelCase_   )},
                     ],
                 ]    ,       )
      @slow
      @require_torch
      def 			lowerCAmelCase__						(				self: Union[str, Any]   ):
             __lowerCamelCase   =						pipeline(
                 task="""zero-shot-image-classification"""    ,       model="""openai/clip-vit-base-patch32"""    ,       )
             # This is an image of 2 cats with remotes and no planes
             __lowerCamelCase   =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
             __lowerCamelCase   =						image_classifier(UpperCamelCase_    ,       candidate_labels=["""cat""", """plane""", """remote"""]   )

             self.assertEqual(
                 nested_simplify(UpperCamelCase_   )    ,       [
                     {"""score""": 0.511, """label""": """remote"""},
                     {"""score""": 0.485, """label""": """cat"""},
                     {"""score""": 0.004, """label""": """plane"""},
                 ]    ,       )

             __lowerCamelCase   =						image_classifier([image] * 5    ,       candidate_labels=["""cat""", """plane""", """remote"""]    ,       batch_size=2   )
             self.assertEqual(
                 nested_simplify(UpperCamelCase_   )    ,       [
                     [
                         {"""score""": 0.511, """label""": """remote"""},
                         {"""score""": 0.485, """label""": """cat"""},
                         {"""score""": 0.004, """label""": """plane"""},
                     ],
                 ]
                 * 5    ,       )




      @slow
      @require_tf
      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             __lowerCamelCase   =						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
             __lowerCamelCase   =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
             __lowerCamelCase   =						image_classifier(UpperCamelCase_    ,       candidate_labels=["""cat""", """plane""", """remote"""]   )
             self.assertEqual(
                 nested_simplify(UpperCamelCase_   )    ,       [
                     {"""score""": 0.511, """label""": """remote"""},
                     {"""score""": 0.485, """label""": """cat"""},
                     {"""score""": 0.004, """label""": """plane"""},
                 ]    ,       )

             __lowerCamelCase   =						image_classifier([image] * 5    ,       candidate_labels=["""cat""", """plane""", """remote"""]    ,       batch_size=2   )
             self.assertEqual(
                 nested_simplify(UpperCamelCase_   )    ,       [
                     [
                         {"""score""": 0.511, """label""": """remote"""},
                         {"""score""": 0.485, """label""": """cat"""},
                         {"""score""": 0.004, """label""": """plane"""},
                     ],
                 ]
                 * 5    ,       )



def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			int						,  _lowerCamelCase :			int)					->    float:






							'''simple docstring'''





							return base * power(_lowerCamelCase						,  (exponent - 1)) if exponent else 1


if __name__ == "__main__":
		print('Raise base to the power of exponent using recursion...')
		lowercase  :					Optional[int]													=       int(input('Enter the base: ').strip())
		lowercase  :					Tuple													=       int(input('Enter the exponent: ').strip())
		lowercase  :					str													=       power(base, abs(exponent))
		if exponent < 0:  # power() does not properly deal w/ negative exponents
				lowercase  :					Tuple													=       1 / result
		print(f"{base} to the power of {exponent} is {result}")