
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      _UpperCAmelCase				:
        @staticmethod
        def 					lowerCamelCase__	(    *snake_case_						,    **snake_case_     ):
          pass






@is_pipeline_test
@require_vision
class      _UpperCAmelCase				(					unittest.TestCase):
    @require_torch
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   pipeline(
          model="hf-internal-testing/tiny-random-clip-zero-shot-image-classification"						,    )
      _snake_case     :						Union[str, Any]						=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     )
      _snake_case     :						Tuple						=   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.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"}],
          ]						,    )

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

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

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

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

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


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

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



"""simple docstring"""
import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)






class      _UpperCAmelCase				(					unittest.TestCase):
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2, 3]     )
      self.assertEqual(x.component(0     )						,    1     )
      self.assertEqual(x.component(2     )						,    3     )
      _snake_case     :						List[Any]						=   Vector()
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   Vector([0, 0, 0, 0, 0, 1]     )
      self.assertEqual(str(snake_case_     )						,    "(0,0,0,0,0,1)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Vector([1, 2, 3, 4]     )
      self.assertEqual(len(snake_case_     )						,    4     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2]     )
      _snake_case     :						List[str]						=   Vector([1, 2, 3, 4, 5]     )
      _snake_case     :						List[Any]						=   Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]     )
      _snake_case     :						Any						=   Vector([1, -1, 1, -1, 2, -3, 4, -5]     )
      self.assertAlmostEqual(x.euclidean_length()						,    2.236						,    3     )
      self.assertAlmostEqual(y.euclidean_length()						,    7.416						,    3     )
      self.assertEqual(z.euclidean_length()						,    0     )
      self.assertAlmostEqual(w.euclidean_length()						,    7.616						,    3     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2, 3]     )
      _snake_case     :						Any						=   Vector([1, 1, 1]     )
      self.assertEqual((x + y).component(0     )						,    2     )
      self.assertEqual((x + y).component(1     )						,    3     )
      self.assertEqual((x + y).component(2     )						,    4     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Vector([1, 2, 3]     )
      _snake_case     :						Union[str, Any]						=   Vector([1, 1, 1]     )
      self.assertEqual((x - y).component(0     )						,    0     )
      self.assertEqual((x - y).component(1     )						,    1     )
      self.assertEqual((x - y).component(2     )						,    2     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   Vector([1, 2, 3]     )
      _snake_case     :						List[Any]						=   Vector([2, -1, 4]     )  # for test of dot product
      _snake_case     :						Union[str, Any]						=   Vector([1, -2, -1]     )
      self.assertEqual(str(x * 3.0     )						,    "(3.0,6.0,9.0)"     )
      self.assertEqual((a * b)						,    0     )
    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(str(zero_vector(10     )     ).count("0"     )						,    10     )
    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(str(unit_basis_vector(3						,    1     )     )						,    "(0,1,0)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   Vector([1, 2, 3]     )
      _snake_case     :						Optional[Any]						=   Vector([1, 0, 1]     )
      self.assertEqual(str(axpy(2						,    snake_case_						,    snake_case_     )     )						,    "(3,4,7)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   Vector([1, 0, 0, 0, 0, 0]     )
      _snake_case     :						Optional[int]						=   x.copy()
      self.assertEqual(str(snake_case_     )						,    str(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Vector([1, 0, 0]     )
      x.change_component(0						,    0     )
      x.change_component(1						,    1     )
      self.assertEqual(str(snake_case_     )						,    "(0,1,0)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n"						,    str(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						str						=   [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
      for x in range(a.height()     ):
        for y in range(a.width()     ):
          self.assertEqual(minors[x][y]						,    a.minor(snake_case_						,    snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						Optional[Any]						=   [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
      for x in range(a.height()     ):
        for y in range(a.width()     ):
          self.assertEqual(cofactors[x][y]						,    a.cofactor(snake_case_						,    snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual(-5						,    a.determinant()     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]						,    3						,    3     )
      _snake_case     :						List[str]						=   Vector([1, 2, 3]     )
      self.assertEqual("(14,32,50)"						,    str(a * x     )     )
      self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n"						,    str(a * 2     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      a.change_component(0						,    2						,    5     )
      self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n"						,    str(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual(7						,    a.component(2						,    1     )						,    0.01     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						int						=   Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]						,    3						,    3     )
      self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n"						,    str(a + b     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						Optional[Any]						=   Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]						,    3						,    3     )
      self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"						,    str(a - b     )     )


    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(
          "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"						,    str(square_zero_matrix(5     )     )						,    )


if __name__ == "__main__":
    unittest.main()

